Kubernetes for SaaS companies: why multi-tenant products need a platform they control
Self-managed Kubernetes fits a multi-tenant SaaS product when the platform team needs to decide exactly how customers are separated, how changes reach production and how the resulting evidence is kept. A generic cluster build asks whether pods start and services resolve. A SaaS cluster build also asks which tenant can reach which workload, which identity a deployment runs under, and whether every one of those answers can be shown to an enterprise buyer's assessor months later. The cluster is therefore not just the place where the product runs. It is the isolation boundary for your tenants and one of the main sources of control evidence for your SOC 2 examination.
That dual role changes the design work. Namespaces, RBAC bindings, network policies, Pod Security Admission levels and resource quotas are no longer tuning details. Each one is a control that someone must be able to describe, configure, test and show as operating over a period. Kubernetes authenticates users through X.509 client certificates, OpenID Connect tokens, webhook token authentication or an authenticating proxy, so the team must decide which identity provider is the source of truth for engineers and how service accounts are scoped. Secrets are stored unencrypted in etcd by default, so encryption at rest and restricted list and watch access are part of the baseline, not optional hardening.
The SOC 2 Trust Services Criteria apply to the system as a whole, and the security common criteria CC1 to CC9 apply to every SOC 2 report. Series CC6 covers logical access, CC7 covers system operations and CC8 covers change management. Many of the answers an assessor will ask for live in the cluster: who holds cluster-admin, how namespace access was granted and reviewed, what the audit log records and where it is retained, and how a deployment moves from a Git commit to a running pod. Ask your SOC 2 auditor early which of these artifacts they expect to sample and in what form, because the cluster design should produce them without manual reconstruction.
DeployOpen plans, builds and documents this platform in infrastructure you control, whether that is your cloud accounts, your data centers or an air-gapped network. The work covers the cluster itself, the identity integration, the hardening baseline, the etcd backup and restore procedure and the documentation that explains how each control is configured and operated. DeployOpen prepares systems, controls and evidence for a compliance assessment, but it does not issue audit reports, attestations or certifications. Only your independent SOC 2 auditor can issue a SOC 2 report, and the scope of that report depends on the system description that your own management writes and stands behind.
Before scoping a build, decide who owns each control after go-live. Platform engineering will usually own cluster configuration, security will own access reviews and policy exceptions, and application teams will own their namespaces and deployment manifests. Write that split down, and confirm with your auditor which team must produce which evidence. A cluster that is well built but has no named owner for its access reviews will still generate findings in the first Type 2 observation period.
Which SaaS requirements shape the cluster build, and where they come from
This table lists the framework and regulatory requirements that most directly change how a multi-tenant SaaS cluster is built, with the source of each and the build decision it affects. Read each row as a design input to settle before namespaces, secrets and exit procedures are configured. The main takeaway is that several rows call for evidence, data exports and contract terms as well as cluster settings, so plan those alongside the configuration.
| Requirement | Source | What it means for the build |
|---|---|---|
| SOC 2 logical access (CC6) | AICPA 2017 Trust Services Criteria, common criteria CC6 | Per-tenant namespaces, least-privilege RBAC and SSO-backed cluster access, with access reviews you can export from the cluster. |
| SOC 2 operations, change and risk (CC7 to CC9) | AICPA 2017 Trust Services Criteria, common criteria CC7 to CC9 | Monitoring and incident records, plus GitOps pull requests and approvals that serve as change evidence for a SOC 2 examiner. |
| Switching notice and transitional period | Data Act, Regulation (EU) 2023/2854, Articles 23 and 25 | A maximum two-month notice period and 30-day transitional period need a tested exit runbook for tenant data and cluster manifests. |
| No switching charges from 12 January 2027 | Data Act, Regulation (EU) 2023/2854, Article 29 | Until that date, reduced switching charges may not exceed direct switching costs, so model export volumes and egress now. |
| Processor contract terms | GDPR, Regulation (EU) 2016/679, Article 28(3) | Processing only on documented instructions and Article 32 security measures. Backups, log stores and subprocessors must be covered in the contract. |
| Secrets stored in etcd | Kubernetes Secrets good practices documentation | Secrets sit unencrypted in etcd by default. Enable encryption at rest, restrict list and watch access, or use an external secrets store. |
| Pod security per namespace | Kubernetes Pod Security Standards and Pod Security Admission | Assign each tenant namespace a Privileged, Baseline or Restricted level, with any exceptions documented and reviewed. |
| NIS2 and Cyber Resilience Act applicability | Directive (EU) 2022/2555 (NIS2); Regulation (EU) 2024/2847 (CRA) | Confirm with counsel whether either applies to your service. The supplied facts do not settle SaaS scope, so do not assume either way. |
Tenant isolation in Kubernetes for SaaS companies: namespaces, RBAC and pod security
The first decision in tenant isolation is how many clusters you will run and how tenants are placed inside them, because every isolation control in Kubernetes is scoped to a cluster. Within a shared cluster, the common building blocks are a namespace per tenant or per pricing tier, role-based access control (RBAC) bindings limited to those namespaces, Pod Security Admission levels set per namespace, and network policies that restrict traffic between namespaces. Each layer addresses a different failure. Namespaces give you a boundary for names, quotas and policy objects. RBAC limits which identities can read or change objects in that boundary. Pod Security Admission controls what a workload may ask the node for, such as host namespaces, privileged containers or host paths. Network policies control which pods can open connections to each other. Namespace separation on its own is one layer. It does not stop a container escape, a privileged pod in another namespace or traffic that a network policy does not block.
Pod Security Admission enforces the three Pod Security Standards (Privileged, Baseline and Restricted) per namespace through labels. A practical starting point is to set the Restricted level on tenant namespaces and to keep system namespaces on a level that the platform components actually need, then run the cluster in audit and warn modes before enforcement. Confirm for your chosen Kubernetes version and distribution how the admission labels are set and which workloads, such as monitoring agents or storage drivers, need an exception. Pair this with RBAC rules that deny tenant identities any access to cluster-scoped objects, to other namespaces and to Secrets listing, since Secrets are stored unencrypted in etcd by default unless encryption at rest is configured.
Shared or dedicated clusters for higher-value tenants is a design decision, not a default. Namespace isolation in one cluster shares the control plane, the node pool, the etcd data and the cluster-wide admission and CRD configuration. Some customers will accept that model under their contract and risk assessment. Others will require a dedicated cluster, a dedicated node pool or a separate account or data center. Make this choice with your risk owners and the contract terms in view, and record the reasoning, the tenants affected and the exit path. A dedicated cluster for one tenant adds an operating cost for each cluster, including upgrades, backups and monitoring, so ask for that cost to be shown separately in any quote.
Kubernetes does not store normal users as API objects. It has no user database and no resource that represents a person. Instead, the API server accepts identities from X.509 client certificates, bearer tokens, webhook token authentication or an authenticating proxy, and then applies RBAC to the identity it extracts. For end users and operators, the usual approach is OpenID Connect (OIDC), where the API server is configured to trust an identity provider and reads the username and group claims from the token. Decide which claims map to Kubernetes users and groups, then bind RBAC roles to those groups rather than to individual people. Confirm the OIDC settings supported by your distribution and identity provider, and test that revoking a user at the identity provider removes cluster access within the token lifetime you accept.
Service accounts used by tenant workloads need the same discipline. Disable automatic token mounting where a pod does not call the API, give each workload its own service account with a narrow role, and audit any ClusterRoleBinding that grants access across namespaces. Before go-live, verify the design with a test run: attempt cross-namespace reads, a privileged pod in a tenant namespace and a connection between two tenant namespaces, and record the results. Those test results and the RBAC and admission configuration form the evidence your team will need later for access control reviews.
Which platform components a SaaS Kubernetes build usually needs
A multi-tenant SaaS platform on Kubernetes depends on a small set of supporting components for delivery, identity, secrets, observability and tenant data. Each one forces configuration decisions that touch tenant isolation and audit evidence, so choose them together. The cards below name the decision each component forces.
Argo CD for GitOps delivery
Argo CD reconciles cluster state from Git, so it becomes the record of what runs in each environment. Decide how Argo CD projects map to your tenancy model, for example one project per product tier or per shared service, and which namespaces and clusters each project may target. Plan SSO for operators so deployment rights follow the same groups used elsewhere. Confirm the high availability and recovery approach for Argo CD itself before it manages production workloads.
Identity provider for customers and staff
Keycloak, authentik and Zitadel can each serve workforce and customer sign-in, but they differ in how they model tenants. Zitadel is positioned for multi-tenant organizations, which makes it a candidate when each customer needs its own organization boundary. Decide whether customer identities share a realm or instance with staff identities, and how tenant claims reach each application. Confirm which protocols each product supports for your applications.
OpenBao for secrets and dynamic credentials
Kubernetes Secrets are stored unencrypted in etcd by default unless encryption at rest is configured, so tenant credentials need an external source of truth. OpenBao can issue dynamic credentials and provides PKI and encryption services under the MPL-2.0 license. Decide how workloads authenticate to OpenBao, confirming which Kubernetes authentication method your version supports, and how each tenant's secret paths are separated. Plan lease lifetimes and the unseal and recovery procedure before go-live.
Prometheus and Grafana for metrics
Prometheus collects time-series metrics and evaluates alert rules, while Grafana visualizes them for operators and, where you choose, for tenants. The key decision is the label model: if tenant identifiers become metric labels, series counts grow with every customer and access becomes harder to enforce in queries. Decide which metrics are tenant-scoped, which stay at cluster level, and how Grafana data source permissions limit each team. Check retention and remote storage needs against your cluster size.
Telemetry pipeline and log storage
OpenTelemetry Collector pipelines standardize how logs, metrics and traces leave applications and the cluster. Grafana Loki or OpenSearch then stores application and audit logs, each with its own query and retention model. Decide where tenant identifiers enter the pipeline, whether they are added at the source, enriched in the collector or left out, and whether sensitive fields are redacted before storage. Audit logs need a separate retention and access path from debug logs. Confirm the storage backend's multi-tenancy controls against your requirements.
PostgreSQL for tenant data
Tenant data stores need high availability and point-in-time recovery that a restore test has proven, not just a configuration that looks correct. Decide the tenancy model in the database: separate databases or schemas per tenant, or shared tables with row-level security and tenant keys. That choice drives backup scope, restore granularity and connection pooling. Plan how one tenant can be restored without affecting others, and how major version upgrades will be staged. Confirm recovery time and recovery point targets with your business owners.
How autoscaling and GitOps delivery work across tenant workloads
A platform team keeps tenant deployments reproducible by making Git the only source of desired state. Namespaces, Deployments, ResourceQuota objects, network policies and Argo CD Application definitions all live in version-controlled repositories, and Argo CD continuously compares that desired state with the live cluster. When someone changes a workload by hand, Argo CD flags the drift and can revert it to what Git declares. The design decision to make early is repository layout: one repository per tenant, one monorepo with directories per tenant, or a shared base with per-tenant overlays. Argo CD AppProject boundaries should then limit which repositories, destination namespaces and cluster resources each tenant team can reach, so a tenant cannot deploy outside its own space. Promotion between environments should move the same tested manifests forward through pull requests or tags, with environment-specific values kept separate from the base configuration. Approvals belong in the merge process, and each promotion leaves an auditable commit history that also serves as change evidence. The GitOps controller itself needs the same discipline. Store the Argo CD installation configuration, its settings and its AppProject and Application resources in Git, and back up any state that is not reproducible from Git. Then rehearse a full rebuild of the controller in a separate cluster. Confirm the high availability topology and the recovery steps with the Argo CD release and the distribution you chose, because the exact procedure depends on those versions. Autoscaling works at two levels. The Horizontal Pod Autoscaler adjusts replica counts for a workload based on observed metrics, while a node-level autoscaler adds or removes worker nodes when pods cannot be scheduled. Both depend on resource requests. Requests tell the scheduler how much CPU and memory a pod needs, and autoscalers reason from them, so workloads without requests produce unreliable scaling. Limits cap what a container can consume. For noisy-neighbor control, combine per-namespace ResourceQuota and LimitRange objects, PriorityClass settings for critical tenant services and PodDisruptionBudgets for planned disruptions. Capacity planning then sets node pool sizes and headroom for scale-out, grouped by tenant tier. Confirm which autoscaling components your distribution supplies, which versions it supports and how it behaves during node drains and upgrades. Kubernetes releases arrive roughly three times per year on a cycle of about 14 weeks, and the project maintains only the three most recent minor releases. The version skew policy requires kube-apiserver to be upgraded one minor version at a time, before kube-controller-manager, kube-scheduler and kubelets, and kubelets may run up to three minor versions behind the API server. Delivery tooling has to fit inside that window. Argo CD, autoscalers, admission controllers and the ingress layer each have their own supported Kubernetes versions, so an upgrade can break reconciliation or scaling without any workload change. Plan the upgrade path as a repeatable process: test each step in a staging cluster, pin component versions in Git, and ask your distribution and each tool vendor for a compatibility statement for every target version before scheduling production work.
Compliance obligations that touch a SaaS cluster
Several frameworks ask for the same cluster evidence from different angles: who can change workloads, how customer data is protected and moved, and how vulnerabilities are handled. The cards below cover the obligations most often raised for SaaS platforms on Kubernetes. Applicability depends on your customers, markets and legal entity, so confirm scope before you design evidence collection.
SOC 2 security criteria CC1 to CC9
The AICPA 2017 Trust Services Criteria include the security common criteria CC1 to CC9, which apply to every SOC 2 report. The other four categories (availability, processing integrity, confidentiality and privacy) are added only when they are in scope. From the cluster, useful evidence includes exported RBAC bindings, Kubernetes audit logs, admission policy settings and approved change records from GitOps pull requests. Confirm with your auditor whether you need a Type 1 or Type 2 report and which observation period applies. DeployOpen prepares systems and evidence for your auditor but does not issue SOC 2 reports.
GDPR processor contracts and security
Article 28(3) requires a processor contract to limit processing to documented instructions, including for transfers, and Article 32 requires security of processing measures. When your SaaS platform acts as processor, the cluster carries much of that work: encryption of Secrets at rest, network policies that separate tenants, access logs and restore tests for backups. Check that your data processing agreement names the systems and sub-processors that run in the cluster. Map each Article 32 measure to a cluster control and a named owner. DeployOpen prepares the controls and evidence but does not certify GDPR compliance.
EU Data Act switching obligations
Regulation (EU) 2023/2854 has applied since 12 September 2025 and requires data processing service providers to let customers switch to another provider or to on-premises ICT infrastructure. The Act sets a maximum two-month notice period and a 30-day transitional period. From 12 January 2027, providers may not impose switching charges. For a Kubernetes platform, this points to exportable manifests, portable data formats and documented migration steps. Confirm with counsel whether your service falls within scope. DeployOpen designs the export path and prepares evidence but does not issue attestations.
NIS2 and Implementing Regulation 2024/2690
NIS2 Annex I places cloud computing, data center and content delivery network providers under digital infrastructure, and managed service providers and managed security service providers under ICT service management. Commission Implementing Regulation (EU) 2024/2690 of 17 October 2024 sets technical and methodological requirements for Article 21(2) measures for these provider types. A cluster you run for customers may fall within these categories depending on your service, so confirm applicability first. Useful evidence includes patch records, incident runbooks and component inventories generated from the cluster. DeployOpen prepares these controls but does not issue compliance statements.
Cyber Resilience Act timing and module A
The Cyber Resilience Act applies to products with digital elements, including software, from 11 December 2027. Article 14 reporting obligations have applied since 11 September 2026 to all in-scope products whenever they are placed on the market. Most products follow self-assessment under module A, while a notified body is needed in defined cases, such as class II important and critical products. If you ship cluster software or Helm charts, keep SBOMs, vulnerability handling records and update logs from the build pipeline. Confirm the product class with your legal team. DeployOpen prepares technical evidence but does not issue conformity declarations.
SEC Item 106 for US registrants
Regulation S-K Item 106 (17 CFR 229.106) sets cybersecurity disclosure requirements for US registrants, including how they describe risk management processes and board oversight. Whether it applies to your company, and how it applies to a SaaS business running customer workloads, should be confirmed with securities counsel. For the cluster, the useful inputs are documented risk assessments, named security oversight roles and timestamped incident records. Ask your team which cluster records feed those descriptions. DeployOpen prepares the operational records and controls but does not prepare or attest disclosures.
What SOC 2 evidence Kubernetes for SaaS companies can generate from the cluster
The cluster produces evidence for several SOC 2 criteria, but only if the company decides in advance which artifact answers which criterion and keeps that artifact in a retrievable form. For logical access in the CC6 series, the starting points are the Role and ClusterRole definitions, their RoleBinding and ClusterRoleBinding objects, and recurring access reviews that compare who holds those bindings against who should. For system operations in the CC7 series, the kube-apiserver audit policy and the exported audit logs show who did what to the control plane and workloads. For change management in the CC8 series, Git history and pull request approvals in the repository that feeds your GitOps controller show who proposed each change, who approved it, and when it reached the cluster.
Two other artifacts need specific attention. Secrets are stored unencrypted in etcd by default, so the encryption at rest configuration, the EncryptionConfiguration file passed to kube-apiserver, is evidence in its own right. Keep the file under version control, record when it changed, and confirm that existing Secrets were rewritten after encryption was enabled. For availability and recovery, etcd snapshot records from etcdctl snapshot save are only persuasive if you also keep restore test results made with etcdutl. A backup that has never been restored in a test gives an auditor little to rely on. Ask your auditor whether availability criteria are in scope, because that decides how much weight these records carry.
A Type 1 report describes the system and assesses whether controls are suitably designed as of a single date. A Type 2 report adds an opinion on whether those controls operated effectively over a period, and that period is what makes continuous collection necessary. An auditor selecting samples from a six or twelve month window will ask for proof that an access review happened in each cycle, that audit logs existed throughout, and that every change in the window has an approval trail. Evidence assembled in the final weeks cannot prove operation earlier in the period. Schedule exports of RBAC state, audit logs and pipeline approvals from the first day of the window, and confirm the retention periods cover the full period plus the time the auditor needs to test it.
Responsibility for the opinion sits with the parties named in the standards. The AICPA's 2018 description criteria, DC 200, govern how management describes the system, and management must write that description accurately, including which parts of the stack the cloud provider or distribution controls. Under AT-C section 205, the service auditor obtains written representations from management and forms the opinion. DeployOpen can plan, configure and document these controls and assemble the evidence, but it does not issue SOC 2 reports or attestations. Before the period begins, ask your service auditor which artifacts they will sample, in what format they want them, and how they will test the access review and change approval records.
How a SaaS Kubernetes rollout moves from design to operations
Each phase produces a decision, a configured control or a piece of evidence that your engineers and security owners approve before the next phase starts. The sequence and its durations are fixed in the written scope, so you know what each gate requires before work begins.
Agree scope and the tenant model
DeployOpen works with your product, platform and security leads to decide how tenants are isolated: namespace boundaries, dedicated clusters for sensitive customers, RBAC roles, and the Pod Security Standards level (Privileged, Baseline or Restricted) enforced per namespace. The group also confirms which systems fall inside the SOC 2 system description and where data may reside. This step closes when your engineers and security owners approve a tenant model document and the written scope that references it.
Choose the distribution and cluster topology
The team selects a distribution that passes CNCF Certified Kubernetes conformance, then chooses between a stacked control plane with etcd on the same nodes and an external etcd cluster. Production control planes start at three nodes behind a TCP load balancer on port 6443, and the kubeadm guidance points to five etcd members for production, which keeps the member count odd. If the clusters run without internet access, the image mirror and private registry are designed here. Your platform owners approve the topology diagram and failure domain plan before build starts.
Integrate identity and secrets
Kubernetes does not store human users as objects, so DeployOpen configures the API server to trust your identity provider through OpenID Connect and maps identity groups to RBAC roles. Secrets are protected in two layers: encryption at rest for Secrets in etcd, and where needed an external store reached through the Secrets Store CSI Driver. Access to list and watch Secrets is restricted to named roles. The step closes when test users sign in, receive only their mapped roles, and cannot read Secrets outside their scope.
Harden the cluster against the CIS benchmark
The team runs an assessment of the cluster against the CIS Kubernetes Benchmark, which covers upstream Kubernetes and several managed services. Each failed check is either fixed or recorded as a documented exception with its compensating control and an owner. Admission enforcement, network policies for tenant traffic and API audit logging are configured in this phase. Security owners approve the scan results and the exception register, and the closing evidence is a re-run of the assessment showing the agreed state.
Build the GitOps and tenant onboarding pipeline
Git becomes the source of truth for cluster configuration, and a GitOps controller applies changes from approved pull requests. Onboarding a tenant becomes a templated change that creates its namespace, resource quotas, RBAC bindings, network policies and Pod Security labels in one reviewed commit. Removing a tenant follows the same path. Your engineers test the pipeline with a test tenant, and the step closes when that tenant is onboarded and offboarded from pull requests with the history retained in Git.
Set up evidence collection from the cluster
DeployOpen maps each in-scope control to the evidence the cluster can produce: RBAC definitions, audit log records, admission policy configuration, Git change history, etcd backup job logs and access reviews. Collection and retention are automated where possible and stored in a location your compliance lead controls. DeployOpen prepares the systems, controls and evidence, but independent auditors issue any SOC 2 report. The step closes when a sample of each evidence type is pulled and approved by your compliance lead.
Hand over with an upgrade plan and tested recovery
The handover package includes runbooks, an etcd backup schedule using snapshot save, and a restore procedure with etcdutl that your team has run in a test environment. The upgrade plan follows the version skew policy: the API server moves one minor version at a time, ahead of controller manager, scheduler and kubelets, and the plan targets the three most recent minor releases the project maintains, which were 1.37, 1.36 and 1.35 as of September 2026. Your platform team approves the plan, and the step closes after a restore test and an upgrade rehearsal are signed off.
What SaaS teams ask before bringing in an outside partner
What drives the cost of a Kubernetes platform for a SaaS product?
The main cost drivers are the number of clusters, the tenant model, the identity and data integrations, the evidence scope and the tooling your team already runs. Each driver changes the work. More clusters mean more control planes, etcd backups and upgrade cycles. A pooled namespace model with shared RBAC is a different build from one with dedicated clusters for sensitive tenants. DeployOpen plans and quotes from a written scope, so the figure follows from these inputs. Ask for a quote that itemizes each driver, lists the systems you already run that will be reused, and states what is excluded.
Is the cost of a Kubernetes build one-time or recurring?
The initial build is one-time. Upgrades, retained support and continuous testing recur. Upstream Kubernetes releases about three times per year on a cycle of roughly 14 weeks, and the project maintains only the three most recent minor releases, so an upgrade plan is ongoing work rather than a single event. Patch support for each minor version runs about one year. Ask the quote to separate three lines: the build fee, any retainer for support and upgrades, and any recurring testing. Also ask how a version upgrade is priced when it falls outside the retainer.
How long does a multi-tenant Kubernetes build take?
The timeline depends on the cluster count, the tenant isolation model, identity integration, the evidence scope and how quickly your organization can approve changes and grant access. No duration applies until the scope is written. Several steps have fixed dependencies: a highly available control plane needs at least three control plane nodes and a load balancer in front of the API server, etcd backups must be tested before go-live, and identity federation depends on your identity provider team. Ask for a milestone plan that shows which steps wait on your team, such as cloud account provisioning, identity provider access and change approvals.
What does our team need to provide for a Kubernetes engagement?
Your team provides named owners, access and approvals. You need a technical owner for the platform, a business owner who signs off scope, and a security contact who approves controls. The partner needs access to your cloud accounts or data center environment, administrative access to the identity provider for federation, a change approval path for production clusters, and a decision on the Kubernetes distribution. For air-gapped sites, you also provide a private registry. Confirm these in the written scope, including who grants access and how long approvals normally take in your organization.
Can our internal platform team build this without an outside partner?
Yes, an internal team can build a Kubernetes platform alone, because Kubernetes is open source under the Apache 2.0 license and the kubeadm tooling is public. The harder part is the operating knowledge. Your team must configure encryption at rest for Secrets, enforce Pod Security Standards per namespace, run tested etcd snapshots and restores, and follow the version skew rules during every upgrade. Assess your team against those tasks. If the same people will also carry on-call duties and product work, plan for the capacity needed to build and then keep the platform current.
Does DeployOpen issue SOC 2 reports for our Kubernetes platform?
No. DeployOpen does not issue SOC 2 reports, attestations or certifications. An independent CPA firm performs the SOC 2 examination and issues the report. A Type 1 report covers the system description and control design as of a date. A Type 2 report adds an opinion on operating effectiveness over a period. DeployOpen prepares the cluster controls, configuration and evidence that the auditor will examine, such as access records, change history and audit logs. Ask your auditor early which Trust Services Criteria are in scope, since that decides which evidence the cluster must produce.
Which Kubernetes controls produce evidence for a SOC 2 examination?
Most evidence comes from access control, system operations and change management. The security common criteria in the AICPA 2017 Trust Services Criteria apply to every SOC 2, and the cluster supplies material for several of them. Typical sources include:
- RBAC definitions and access reviews, mapped to logical access criteria
- Audit logging of API server requests, retained and protected
- Encryption at rest for Secrets in etcd, plus restricted list and watch permissions
- Pod Security Admission labels that show enforced namespace standards
- Git history from GitOps delivery, showing who approved each change
The criteria points of focus are guidance, not separate requirements, so confirm with your auditor which controls they will test and in what period.
How DeployOpen scopes and delivers a SaaS Kubernetes platform
DeployOpen plans, implements, hardens, documents and supports self-hosted open-source platforms inside your own cloud accounts, data centers or air-gapped networks. For SaaS companies, tenant isolation, cluster access and control evidence are designed in from the start, so questions from customers and auditors can be answered from the cluster itself.
How we scope
- The written scope names each cluster, tenant model, namespace boundary and RBAC role set.
- Autoscaling, GitOps delivery and SOC 2 evidence collection are scoped as deliverables, each with an agreed acceptance check.
- Scope, deliverables and timelines are agreed in writing before work starts, and the quote follows from that scope.
How we build
- Cluster bootstrap uses a chosen distribution, with control plane nodes and an API load balancer sized for your environment.
- Identity uses your OIDC provider, Pod Security Admission is set per namespace, and Secrets are encrypted at rest.
- etcd runs as an odd-sized cluster, with snapshot backups and a restore procedure rehearsed before go-live.
How we hand over
- Handover includes architecture records, runbooks for tenant onboarding, and restore and upgrade procedures your team can run.
- Control evidence is documented from cluster settings, RBAC bindings and audit logging, mapped to your SOC 2 criteria.
- Handover notes separate the evidence we prepare from the SOC 2 opinion, which an independent CPA firm issues.
How we support
- Ongoing support, upgrades and continuous testing are available as retainers, scoped in writing like the original build.
- Kubernetes upgrades follow the version skew policy, moving the API server one minor version at a time.
- Security testing of the tenant boundary and API surface can be added as a separate engagement or retainer.

