Why self-hosted secrets management for SaaS companies starts with pipelines and tenants
For a SaaS company, self-hosted secrets management starts with two questions: where long-lived credentials sit today, and what one leaked credential can reach. Most engineering teams keep database passwords, cloud access keys and registry tokens in CI variables, and many store application secrets as native Kubernetes Secrets. Those Secrets are stored unencrypted in etcd by default, so anyone with broad read access to the cluster or its backups can read them. The practical short answer on platforms is this: OpenBao is the option to evaluate first if you want an MPL-2.0 licensed secrets manager under open governance, since it is a community fork of Vault. Infisical is MIT-licensed except for content in its ee directories, which carry a separate enterprise license, so your legal team must confirm which features you would run. The Business Source License 1.1 that now covers HashiCorp Vault from version 1.15.0 onward, with IBM named as licensor, is the reason many Vault users are reopening this decision. Confirm the license terms that apply to the exact versions you plan to run.
SaaS differs from regulated sectors mainly in blast radius. A bank or hospital typically protects a bounded set of systems, while a SaaS provider may hold one credential that opens the data of hundreds of tenants. That changes the design priorities. Pipeline jobs should authenticate with short-lived identity tokens, such as JWT or OIDC logins, rather than stored secrets, and each project should receive a policy limited to the paths it needs. Application workloads should receive dynamic database credentials that expire on a lease, so a leaked value is only useful for a short window. Tenant isolation should be designed in the secrets layer too: separate namespaces or mounts per team or tenant, with policies that prevent one tenant's workload from listing another's paths. Ask your partner to show how a stolen CI token would be contained, how revocation of one tenant's credentials works without touching others, and which audit records show which job read which secret.
Which SaaS requirements shape the secrets design
This table maps each obligation a SaaS company faces to its source and to the concrete secrets design it forces. Read it as a checklist for architecture reviews: each row names what the build must do, not just what the law says. The main takeaway is that SOC 2 and GDPR drive most of the design, while the Data Act and sector rules add switching and evidence requirements that apply only to certain customers.
| Requirement | Source | What it means for the build |
|---|---|---|
| SOC 2 security common criteria CC1 to CC9 | AICPA 2017 Trust Services Criteria; every SOC 2 covers the security common criteria | Assessors will ask who can read production secrets, how access is granted and removed, and whether reads are logged. Plan for per-team access policies and reviewable audit records from day one. |
| Processor security duties for customer data | GDPR Article 32 (security of processing), applied through Article 28(3) processor contracts | Encrypt secrets and keys protecting customer data, restrict access to documented instructions, and be ready to show these measures in a contract or audit. Confirm with counsel how your processor terms cite these measures. |
| Least-privilege access for workloads | SOC 2 CC6 access controls, read through the Kubernetes secrets good practices guidance | Native Kubernetes Secrets are stored unencrypted in etcd by default, so pods should pull short-lived credentials from OpenBao through an authentication method rather than receiving static values. |
| Short-lived database and cloud credentials | OpenBao dynamic secrets with leasing and automatic revocation | Issue per-job or per-pod database users that expire and are revoked, which limits the damage from a leaked credential and removes long-lived passwords from CI variables. |
| Namespaces per team or tenant | OpenBao namespaces documentation; SOC 2 access scoping | Separate policies, mounts and audit scope by team or customer. Confirm with the vendor how namespace isolation and audit filtering behave at your expected count of tenants before committing to one model. |
| Customer switching to another provider or on-premises | EU Data Act (Regulation (EU) 2023/2854), Articles 23, 25 and 50 | Keep secrets exportable and documented so customers can move workloads. Maintain a runbook for migrating tenant configuration, including how secret references are re-pointed. |
| Switching charges | EU Data Act, Article 29, no switching charges from 12 January 2027 | Do not build exit costs into the secrets platform. Price your export path so that reduced charges before that date never exceed costs directly linked to switching. |
| Multi-factor authentication for administrator access | FTC Safeguards Rule, 16 CFR 314.4(c), applies only where a customer is a covered financial institution | Where a SaaS customer is a financial institution, require MFA for operators who can reach the secrets platform and document that control for the customer's review. |
| Unique user identification and audit of ePHI access | HIPAA Security Rule, 45 CFR 164.312, applies only where a customer is a covered entity or business associate | Use named identities for every human and workload, and record every secret read that touches ePHI-linked systems. Confirm with your healthcare customers which records they need you to retain. |
Which open-source platforms fit SaaS secrets workloads
SaaS teams usually need secrets for three things at once: pipeline jobs, Kubernetes workloads and per-tenant or per-team isolation. The platforms below differ mainly in license terms, dynamic credential support and how namespaces are modeled, so the licensing and feature checks matter as much as the feature list.
OpenBao as the core secrets store
OpenBao is an open source secrets manager licensed under MPL-2.0 and hosted under the OpenSSF, currently a Sandbox project. It covers key/value storage encrypted before it reaches the backend, dynamic Kubernetes and SQL database credentials, leasing with automatic revocation, and namespaces for separating teams or tenants. Check which storage backend fits your operating model: PostgreSQL or integrated Raft storage are the officially supported HA options. The latest release in the supplied facts is v2.7.1, published October 1, 2026.
OpenBao auth for pipelines and pods
For CI/CD and Kubernetes, the relevant auth methods are JWT/OIDC and the Kubernetes method, which let a pipeline job or pod log in with its platform identity instead of a stored password. AppRole is the documented choice for servers, while Userpass is recommended only for developer machines. Confirm that your CI system can issue the OIDC token claims your policies need, and test per-project policy scoping before you migrate any production credentials.
Infisical for developer-facing secrets
Infisical is a platform for secrets, certificates and access, licensed under MIT except for content in ee directories, which carries a separate enterprise license. Its release v0.166.8 was published October 15, 2026. Before you standardize on it for SaaS workloads, confirm in writing which dynamic credential types, Kubernetes integrations and multi-tenant project controls ship under the MIT terms, and which require the enterprise license, because the boundary determines what you can run without a commercial agreement.
HashiCorp Vault licensing review
Vault version 1.15.0 and later is licensed under the Business Source License 1.1, with IBM named as licensor. This is not an OSI-approved open source license, so it sits outside the open source definition that many SaaS procurement policies require. Have your legal team review the license text for your use case, including any competing-service restrictions that could affect a product you sell. This review is the reason many teams evaluate OpenBao as the successor path for existing Vault workloads.
Keycloak or ZITADEL for human access
Keycloak and ZITADEL are identity providers, not secrets stores. Use them to authenticate engineers and support staff who sign in to the secrets manager, and to federate single sign-on into your admin consoles. Keycloak is licensed under Apache-2.0 and ZITADEL under AGPL-3.0, so the license review for each should be separate. Keep machine identities for pipelines and workloads on the secrets platform's own auth methods, so that an identity provider outage does not block production deployments.
Choosing a combination
Most SaaS teams do not need one tool for every role. A common pattern is OpenBao for machine secrets, dynamic database credentials and encryption, with an identity provider for human sign-in. Infisical can sit in front of developer workflows if its feature coverage meets your needs. Document which platform owns which secret type, who can change policies and how audit logs reach your SIEM, since split ownership is where gaps usually appear.
How OpenBao and Infisical connect to pipelines, clusters and tenants
Pipeline jobs are the most common place where long-lived credentials end up in variables and files. The usual replacement is a JWT or OIDC login from each job to OpenBao, which issues a token scoped to that job's project and branch context and expires when the job ends. Database and cloud credentials can then be generated on demand instead of stored, so a leaked job log exposes at most a short-lived credential.
- Per-job login: Each job authenticates with the identity token issued by the CI platform, and OpenBao's JWT/OIDC auth method maps claims such as project path or branch to a policy.
- Dynamic database credentials: The database secrets engine creates a unique user with a lease, and OpenBao revokes it automatically when the lease ends or the job is cancelled.
- Short-lived cloud access: Cloud credentials are issued per job rather than stored as static keys, which narrows the blast radius of any single run.
- Scoped policies per project: Each project or environment gets its own policy, so a staging job cannot read production paths.
- Audit per read: Audit logs record which identity read which secret path, which is the evidence a security team needs when reviewing pipeline access.
Before rollout, confirm with your CI platform which claims its identity tokens carry, and test how revocation behaves when a job is cancelled mid-run.
Native Kubernetes Secrets are stored unencrypted in etcd by default, so a platform team needs more than the default object. The Kubernetes good practices guidance recommends encryption at rest, least-privilege RBAC that restricts list and watch access, or an external store reached through the Secrets Store CSI Driver. OpenBao fits the external store path, and the Kubernetes auth method lets pods authenticate with their service account identity.
- Kubernetes auth method: Pods present their service account token, and OpenBao binds that identity to a role and policy, so no static credential is placed in the pod spec.
- Injector or CSI approach: An injector sidecar writes secrets into the pod, while the Secrets Store CSI Driver mounts them as volumes; confirm which pattern your team can operate and audit.
- Encryption at rest for etcd: If any secret still lives in Kubernetes objects, configure encryption at rest and restrict list and watch permissions.
- Dynamic database credentials for pods: Applications receive leased database users that rotate without redeploying the workload.
- Where OpenBao runs: Decide whether the OpenBao cluster sits on the same cluster it serves, which adds a bootstrap dependency, or on a separate cluster or VM tier.
Confirm the Kubernetes version you run against the current supported release line, since the version skew and patch windows affect when you must upgrade both the cluster and the secrets integration.
A SaaS company that serves many customers or internal teams needs isolation between them in the secrets layer as well as in the application. OpenBao namespaces let a platform team delegate administration of a subtree to each team or tenant, with its own auth methods, policies and secrets engines. The design choice is how many namespaces, how policies are generated, and who holds administrative rights over them.
- One namespace per team or tenant: Each namespace gets its own policies and secrets engines, which keeps a tenant's data paths separate from others.
- Per-tenant policies generated from templates: Automate policy creation from a tenant record so that onboarding does not depend on hand-edited files.
- Delegated administration: Give each namespace administrators only the rights they need, and keep the root of the namespace tree under a small platform group.
- Audit separation: Keep audit logs per tenant where possible, so a customer's audit request does not expose other tenants' records.
- Infisical as an alternative model: Infisical organizes secrets by project and environment, so confirm whether its project model matches your tenant isolation requirements.
Ask any implementation partner to show how a new tenant is provisioned end to end, including policy creation, auth setup and removal of a departed tenant.
Every environment above depends on the OpenBao cluster that holds the control plane. OpenBao's high availability design uses one active node that holds a lock in the data store, with standby nodes that forward or redirect requests. The two officially supported HA backends are integrated storage (Raft) and PostgreSQL, and the docs describe PostgreSQL as easier to operate safely than Raft.
- Raft or PostgreSQL: Raft keeps storage inside the OpenBao nodes, while PostgreSQL moves storage to a database team you may already run; choose based on who will operate and back up each piece.
- Standby read scaling: Since OpenBao 2.5.0, Raft standbys can serve read-only operations, and v2.7.0 extended this to PostgreSQL, which helps with horizontal read load.
- Etcd guidance for Kubernetes hosts: If the cluster hosting the control plane uses etcd, Kubernetes documentation recommends an odd number of members, with five members in production.
- Etcd backups: Back up etcd with the snapshot save command and test the restore path with the restore tool, because a backup you cannot restore is not a recovery plan.
- Load balancing and failover tests: Put a load balancer in front of the nodes and rehearse leader failure before go-live.
Confirm the storage backend, node count and backup retention with your partner, and ask for the results of a recent restore test.
How a SaaS secrets rollout moves from inventory to rotation
The sequence starts with an inventory of where credentials live, then adds authentication, key custody, a controlled pilot and migration, so that each step leaves evidence a team can check before the next one starts. Durations depend on scope and are set in the written plan agreed before work begins.
Inventory secrets across repos, pipelines and clusters
DeployOpen works with your platform and security leads to list every place a credential lives: repository files and CI variables, pipeline settings, Kubernetes Secrets, environment files, service accounts and database users. Each entry records the secret type (static, dynamic, certificate or encryption key), the owner, the consuming workload and the rotation history. The step is done when the inventory is reviewed by the owning teams and every item has a named owner and a planned disposition.
Design authentication for each workload
For each class of workload, the team decides how it proves its identity to OpenBao: CI jobs through JWT/OIDC login from the pipeline provider, Kubernetes pods through the Kubernetes auth method, and long-running servers through AppRole. Human access is handled separately, usually through OIDC with login MFA, and developer machines should use a different method from servers. The output is an authentication matrix and a policy per project, namespace or tenant, reviewed against least privilege. Confirm which auth methods your identity provider and platform versions support before committing to the matrix.
Set unseal and recovery key custody
Before any production secret is written, the team defines how the OpenBao cluster is unsealed after a restart, who holds unseal and recovery material, and how that material is split so that no single administrator can recover the cluster alone. DeployOpen documents the custody procedure, the storage location for each share and the emergency access path, and tests a restart in a non-production cluster. Ask your provider to confirm the key ceremony with your security leadership. The step closes when custody is signed off and the procedure is written into the runbook.
Run a pilot with one pipeline and one service
The team chooses one CI pipeline and one service that has real secrets, then moves them to short-lived credentials from OpenBao while the old static values remain in place as a fallback. The pilot checks that the job authenticates, reads only the secrets its policy allows, and fails closed when access is denied. Results are compared against the inventory entry. The pilot is complete when the owners accept the behavior and the fallback has been removed or scheduled for removal.
Issue dynamic database credentials for one tenant-facing service
For one service that serves tenant traffic, the team configures OpenBao's database secrets engine so the application receives short-lived database credentials that are revoked automatically when their lease ends. Connection pooling, reconnect logic and tenant isolation are tested under realistic load in staging, and the team confirms that a leaked credential expires without an application outage. The output is a documented lease duration, a revocation test and an application change record. Confirm the database engine and driver support with your application team before the change is scheduled.
Migrate static secrets and Kubernetes Secrets
Remaining static secrets are migrated in waves by namespace or team. Kubernetes Secrets are moved to OpenBao, or exposed through the Secrets Store CSI Driver, and encryption at rest is configured for the cluster datastore in the meantime, since Secrets are stored unencrypted in etcd by default. RBAC is narrowed so that list and watch access on Secrets is limited to the workloads that need it. Each wave closes when the old copies are deleted from repositories, pipelines and clusters and the inventory entry is marked complete.
Export audit logs to the SIEM
The team configures OpenBao audit devices and forwards the logs to the SIEM your security operations team uses, so that every secret read, login and policy change is searchable by identity and workload. Alert rules are written for unusual access patterns, such as a job reading secrets outside its project or repeated failed logins. The step is done when a test read produces a matching event in the SIEM and the security team has confirmed the alert routes. Confirm with your SOC which log format and retention they require.
Write rotation runbooks and test restores
The final phase produces the operational evidence: a rotation runbook for each secret type, a schedule for rotating the remaining static credentials, and a documented backup and restore procedure for the OpenBao storage backend. The team restores a backup into an isolated environment, confirms that unseal works with the custody material, and records the result with timestamps. The rollout is complete when the restore test has passed, the runbooks are approved by the owning teams and the handover to your operations group is signed.
What evidence a SaaS SOC 2 audit asks for from secrets tooling
What written policies does a SOC 2 auditor expect for secret storage and rotation?
The auditor expects a documented policy that states where secrets may live, who owns each secret class, how often static credentials rotate, and what happens when a secret is suspected to be exposed. The policy should match what the platform actually enforces. In a self-hosted OpenBao or Infisical deployment, the policy is usually backed by path layout, lease durations for dynamic credentials and rotation settings. Auditors compare the written policy with configuration exports and sample records, so gaps between the document and the system tend to surface as findings. DeployOpen can help draft the policy against the security common criteria and document the configuration that proves it. The policy itself, and the judgment that it is adequate, remain the organization's responsibility and the auditor's to test.
How do access reviews of secrets policies and roles work for SOC 2?
Auditors look for a recurring review in which named owners confirm that each policy, role and auth binding still matches current team membership and need. For secrets tooling, the evidence is an exported list of policies, roles, AppRoles, Kubernetes auth bindings and CI JWT roles, with the reviewer, date and the decisions recorded. Removed engineers and decommissioned pipelines should show up as closed items in the review. The review cadence is set by the organization's own policy, and the auditor tests whether it happened as described. The review tool is usually a ticket or GRC workflow, with the secrets platform supplying the data. Confirm with your auditor which review period they will sample.
Which audit logs of secret reads does SOC 2 require from a secrets manager?
Auditors ask for records showing who or what read or changed each secret, when, and from where, and they ask how those records are protected and reviewed. In OpenBao, the audit devices write request and response entries, which should be sent to a log store outside the cluster so that operators cannot quietly alter them. The evidence set typically includes a sample of reads traced back to a named identity such as a Kubernetes service account, a CI job or a human user, plus proof that the log pipeline was running over the audit period. Log retention and the review process belong in your policy. Confirm with your auditor which log fields and retention length they expect, and whether they want the SIEM export tested as part of the sample.
What proves that secrets are encrypted at rest in a self-hosted deployment?
The evidence is a configuration record showing how encryption at rest is set up, plus proof that the stored data is not readable without the unseal material. For OpenBao, encryption happens before data is written to the storage backend, whether integrated Raft storage or PostgreSQL. Auditors typically ask for the storage configuration, the seal configuration, a description of where the unseal or recovery material is held, and a sample showing that the backend contents are ciphertext. If the database or disk underneath is also encrypted, that layer should be documented separately. For Kubernetes-hosted workloads, the native Secrets in etcd are stored unencrypted by default, so the encryption configuration of etcd and the Secrets Store integration should also appear in the evidence.
What do backup and restore test records look like for a secrets platform?
A restore test record shows that a backup was taken, that it was restored into a separate environment, and that the restored platform served the expected secrets and audit trail. Auditors look for the date, the operator, the backup identifier, the target environment, the outcome and any defects raised. For a self-hosted OpenBao cluster, the test should also cover the recovery keys and the unseal procedure, because a backup without the matching key material is not recoverable. Kubernetes etcd guidance recommends a backup plan and uses snapshot tooling, so the record for an etcd-backed cluster should reference that process too. Ask the auditor how many tests they expect in the period and whether restores into a non-production environment satisfy them.
Which change records cover unseal, key custody and root token handling?
Auditors expect change records for every event that touches the root of trust, including initialization, unseal key distribution, rekeying, root token generation and revocation, and seal or storage migrations. Each record should name the approvers, the participants who held key shares, the date, the ticket and the verification step. The records should show dual control or split knowledge where the policy requires it. Keys held in escrow or a password vault should have their own custody log. These records usually live in the change management system rather than in the secrets platform, so they must be linked to the platform's audit events. DeployOpen can help define the procedure and the record template. Custody decisions are the organization's to make and must be approved by its own governance.
Does DeployOpen issue the SOC 2 report for our secrets platform?
No. DeployOpen prepares systems, controls and evidence for a compliance assessment, but it does not issue SOC 2 reports, attestations or certifications. The AICPA sets the 2017 Trust Services Criteria used in SOC 2 examinations, and an independent CPA firm performs the examination and issues the report, either as a Type 1 report on design as of a date or as a Type 2 report that also covers operating effectiveness over a period. DeployOpen's role is to configure the secrets platform, document how each control operates, collect the evidence described above and hand it to your team and your auditor. Ask your audit firm which evidence format and sample periods they will accept before work starts.
Can our own team produce this evidence without an implementation partner?
Yes, many engineering and security teams can produce this evidence in-house if they have the time, documented procedures and someone who owns each control. The main effort is not the export of logs or configuration, but keeping records current across the audit period, which is where many findings originate. A partner's value is usually in designing the control set, building repeatable evidence collection and running restore tests on a schedule. Whether to build internally or engage a partner depends on your team's capacity and the size of the audit scope. The engagement scope should be written down before work starts, so you know which records DeployOpen produces and which your team retains.
Moving off Vault after the BSL change: what to check before migrating
Before any migration plan is written, a SaaS team should know exactly what its current Vault deployment does, because the license change is only the trigger, not the scope. HashiCorp Vault from version 1.15.0 onward is licensed under the Business Source License 1.1 with IBM named as licensor, which the Vault LICENSE file shows is not an OSI-approved open source license. OpenBao is the community fork under MPL-2.0, and its migration guide is the document to read first. Confirm in that guide which Vault versions it covers, whether your current version is among them, and whether it treats a direct in-place upgrade or a parallel cluster with data copy as the supported path. Do not assume that a Vault 1.15.0 or later deployment can be swapped binary for binary without checking.
The inventory should list five things, each tied to a SaaS workload: policies (including the per-team and per-tenant namespaces, since CI runners, Kubernetes service accounts and tenant tooling often depend on named policies), auth mounts (Kubernetes, JWT/OIDC for pipeline jobs, AppRole and any LDAP or TLS certificate methods, each with its role bindings and token TTLs), dynamic secrets engines (database roles, cloud credential roles and their rotation statements), active leases (which leases must be revoked, drained or re-issued during cutover) and audit devices (where logs go today and what the SIEM parses). Export configuration with your own tooling, record the Vault version and storage backend, and confirm with the migration guide which of these objects carry over and which need recreation. Each step that depends on your version, storage backend or auth plugins should be marked as unconfirmed until it is tested in a staging cluster.
What does self-hosted secrets management cost a SaaS company and how long does it take?
What are the main cost components of self-hosting OpenBao for a SaaS company?
The cost splits into infrastructure, integration work, operations time and the partner scope, if you use one. Infrastructure covers the OpenBao nodes, the storage backend, backups, load balancing and the environments you run for staging and production. Integration work covers each CI pipeline, Kubernetes workload and service that moves from static credentials to OpenBao. Operations time covers upgrades, monitoring, unseal procedures and on-call. OpenBao itself is MPL-2.0 licensed, so there is no per-secret or per-call license fee in the open-source edition, but you should confirm the feature set you need against the current OpenBao documentation. Ask any partner for a quote that lists each component separately, with who pays for each one.
Which costs are one-time and which recur every month?
One-time costs include the initial design, the migration of secrets from code, configuration files and CI variables, the first integration of each pipeline and service, and the setup of high availability and backup testing. Recurring costs include compute and storage for the cluster, backup retention, upgrades to new OpenBao minor and patch releases, on-call coverage, periodic rotation reviews, audit log storage and any support retainer. A common planning mistake is treating the migration as a one-off when new services keep arriving, so budget a recurring share for onboarding each new workload. Ask a quote to separate these two groups so you can compare the first year with later years.
What drives the cost of integration work for CI/CD and Kubernetes?
Integration effort scales with the number of distinct consumers and how different they are. Each GitLab or other pipeline that switches to JWT/OIDC login needs its own policy scoped to the project. Each Kubernetes namespace or workload needs an auth role, and you choose between injector, CSI or direct API patterns. Dynamic database credentials add work per database engine and per application connection pool. Legacy services with hard-coded credentials usually cost the most because they need code changes and a rollout window. Ask the partner to inventory consumers by type, count the ones that need code changes, and price those separately from configuration-only changes.
How long does it take to reach a first pilot with OpenBao?
The time to a first pilot depends on the state of the environment, the team's familiarity with Kubernetes and OpenBao, and how many consumers the pilot includes. A pilot usually needs an agreed architecture, a non-production cluster, one or two auth methods and a single low-risk workload or pipeline. Delays most often come from waiting for network paths, identity provider configuration, change approvals and the availability of the internal owners who must sign off on policies. No duration is stated here because none has been supplied for this scope. Ask any partner for a written timeline with dated milestones and named dependencies on your side.
What does the internal team need to provide during the rollout?
The internal team provides decisions and access rather than most of the build work. You need a named owner for secret policies, engineers who understand each pipeline and service, access to Kubernetes clusters and CI systems, a process for approving changes to production, and staff who can hold unseal and recovery material under your key custody rules. Platform engineers should also be ready to take over runbooks for upgrades and backups. Confirm these roles early, because the most common slowdown is a service owner who is not available to test a changed credential path.
Can a small SaaS engineering team run OpenBao on its own?
A small team can run OpenBao alone if it has someone comfortable with Kubernetes or Linux operations, a tested backup and restore procedure, documented unseal steps and monitoring for the cluster. The harder parts are high availability design, upgrades that keep the cluster healthy, and incident response when a node fails during business hours. Many teams start with a partner for the design, migration and runbooks, then take over operations. Whether your team can carry this alone depends on your on-call capacity and on how many services will depend on the cluster, so assess that before you commit.
How do I request a fixed-scope quote for self-hosted secrets management?
DeployOpen does not publish a price list. Most engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts, and a quote follows from that written scope. To request one, prepare an inventory of pipelines, Kubernetes clusters, databases and services that will consume secrets, the current secret storage locations, the target environments, and any requirements for HSM, air-gapped operation or audit log delivery. Ask for the quote to list the one-time work, the recurring support options and the assumptions about your environment. Ongoing support, upgrades and continuous testing are available as retainers, and they can be quoted separately.
How DeployOpen scopes and supports SaaS secrets deployments
DeployOpen plans, implements, integrates, hardens, backs up, documents and supports OpenBao or Infisical inside the client's own cloud accounts or Kubernetes clusters, so the secrets store, its storage backend and its audit logs stay under the SaaS company's control. In practice, that means the work starts with a written scope that names the clusters and regions in play, the CI/CD systems that will authenticate to the store, the database engines that will issue dynamic credentials, the namespace layout per team or tenant, and the SIEM that will receive audit output. A written scope is the document that determines the quote, so a team that cannot yet list its pipelines, clusters and database engines should expect the first step to be discovery rather than build.
Most engagements are fixed-scope, with deliverables and timelines agreed in writing before work begins. Those deliverables typically cover the deployed store, the authentication configuration for pipelines and workloads, the policies that scope each project or tenant, the backup and restore procedure, and the operating documentation your engineers will use after handover. DeployOpen does not publish a price list. Pricing follows from the written scope, so the useful question to ask any partner, including DeployOpen, is which items are one-time work and which recur, such as cluster capacity, storage, upgrades and support. Ask for the assumptions behind the estimate, including how many integrations are counted and what happens if the number of tenants grows during the project.
After go-live, ongoing support, upgrades and security testing are available as retainers. This matters for a SaaS company because OpenBao and Infisical both release on their own cadence, and Kubernetes versions move on a roughly 14-week cycle according to the Kubernetes release cycle page, so a version bump can affect the store, the injector or CSI driver and the cluster together. Before signing, confirm who performs upgrades in each environment, how restore tests are scheduled, and whether penetration testing of the secrets path and the tenant isolation model is in the retainer or priced separately. Written answers to these questions are more useful than any general claim about support coverage.

