Hyperswitch card vault deployment and PCI DSS scope

Where card data is stored decides which systems fall under PCI DSS and who answers for them. This page compares the three Hyperswitch vault models and the build steps for each.

On this page

Hyperswitch card vault deployment and PCI DSS scope: where card data lives

Before go-live, a team deploying self-hosted Hyperswitch has to decide where card numbers are stored, because that choice determines which systems hold account data and who carries PCI DSS responsibility. The vault model is the first decision in the card data design, and it is hard to change once payment traffic and stored tokens exist. Settle it in writing with the payments owner, the security lead and the qualified security assessor before the deployment design is frozen.

Hyperswitch stores card data in its card vault, also called the locker. The vault is a separate Rust service in the juspay/hyperswitch-card-vault repository, distinct from the Router app server, and the architecture docs describe it as built for PCI DSS requirements. The Hyperswitch docs document three self-hosted vault models: self-hosted with the native Hyperswitch Vault, self-hosted orchestration with an external PCI vault provider such as VGS or Tokenex, and self-hosted orchestration with the SaaS Hyperswitch Vault. Each model places the cardholder data environment in a different location, so the team should map each option to its own network, accounts and responsibilities before choosing.

Under the self-hosted, in-house PCI model, the Hyperswitch docs state that the merchant is fully responsible for PCI DSS certification and data handling. That sentence is the core of the decision. Choosing the in-house vault means your organization operates the vault service, its keys, its database and its access controls, and it owns the evidence an assessor will request for them. Choosing an external or SaaS vault shifts part of the storage burden to a provider, but it does not remove your responsibility for the systems that still touch card data. Ask the provider for its own attestation documents and the responsibility matrix that shows which PCI DSS requirements it covers.

Scope follows the data flow, not the name of the vault. A team that checks only the card vault will miss much of the scope. Trace a card number from the checkout SDK through the Router, then list every place it can persist or appear: Router and scheduler logs, error traces, Redis entries, PostgreSQL tables and replicas, backups and snapshots, Kubernetes secrets and config, and any Control Center screen or support export that displays card details. Also include the people and accounts that can reach these systems, including Control Center users and operators with database or cluster access. Each item that stores or transmits card data belongs in the scope inventory.

Treat the scope inventory as a working document, and confirm the final decision with your qualified security assessor (QSA). The inventory should list each component, the data it may hold, the network path, the owner and the control evidence available. Ask the QSA to review the vault model, the data flow diagram and the scope boundary before build work starts, since changing the boundary after deployment is far more expensive. Costs and assessment effort depend on the chosen model and the size of the scope, so ask the assessor and any vendor for a written scope statement that matches your data flow diagram.

Which Hyperswitch components touch card data

Hyperswitch is made of several components, and only some of them are designed to handle card data. The card vault is the one the architecture docs identify for storing card data, while the others handle routing, payment state, configuration or the shopper interface. Map each component against your chosen vault model before you set scope, and confirm the exact data path with the vendor documentation and your own configuration.

Card vault (locker)

The card vault, also called the locker, is a separate Rust service in its own repository. The architecture docs describe it as the component that stores card data and that is built for PCI DSS requirements. In the in-house model it is the main candidate for the cardholder data environment, so confirm with the vendor documentation which records, logs and backups it holds and where its database runs in your environment.

Encryption service for key management

The encryption service handles key management for data the platform encrypts. Who can decrypt stored card data depends on how keys are held, so this service sits on the audit path for any PCI DSS assessment. Confirm with the vendor documentation whether it receives plaintext card data or only key material, where its keys are stored, and whether your team uses a cloud or on-premises key management system with it.

Rust core router

The Rust core app server handles routing, retries, vaulting and observability. It sits between your checkout and the processors, so it may carry card data in transit during a payment request, depending on your integration path. Check whether tokenization happens before a request reaches it, how request and response bodies are logged, and which network paths reach it from outside your cluster.

Router and Scheduler services

Hyperswitch runs two app services: Router serves payment API traffic, and Scheduler runs in Producer and Consumer roles to process scheduled work from its queue. Both read and write payment records in PostgreSQL and use Redis. Ask the vendor whether either service ever decrypts vault data or only handles token references, and confirm which pods in your environment can reach the card vault.

PostgreSQL and Redis data stores

PostgreSQL is documented with a master and replica setup, and Redis serves caching and the scheduler queue. Both hold payment state that can reference tokens, so whether they hold card data depends on the vault model and configuration. Confirm which tables and cache keys contain token references, and whether any full card number or encrypted card field is ever written to them, including in logs, backups and replica copies.

Control Center and client SDKs

The Control Center is the open source merchant dashboard for connecting processors and viewing payments, refunds and disputes. Client SDKs for web, Android, iOS, React Native and Flutter run in shopper browsers and apps, where card details are entered. Confirm whether the SDKs send card fields directly to the vault, and whether the dashboard can show full card numbers to staff, since both decide which screens and devices fall in scope.

Which vault model fits your PCI program and team

This table compares the three self-hosted vault models Hyperswitch documents, showing when each fits your team and how key custody, vault uptime, assessment evidence and vendor dependency change. Read each row as a set of trade-offs, and use the final row to confirm with your assessor what remains in scope under the model you choose.

ModelWhen it fitsKey custody, uptime and ownershipAssessment evidence and vendor dependency
Self-hosted, native Hyperswitch VaultYour team wants card storage in-house and can staff full PCI DSS certification for the stack.You own key custody through the encryption service and operate vault uptime in your own clusters.Your assessor reviews the vault, key management and hosting as your own environment. Vendor dependency is limited to the software.
Self-hosted orchestration, external PCI vault (VGS or Tokenex)Your team wants a specialist provider to hold card data while you keep routing and orchestration in-house.You still run Hyperswitch, its database, Redis and network paths. Confirm with the provider who holds key custody and where.Request the provider's current PCI DSS attestation and responsibility matrix. Vendor dependency is contractual and technical.
Self-hosted orchestration, SaaS Hyperswitch VaultYour team runs the orchestration layer and accepts a hosted vault operated by Juspay.Vault uptime follows the provider's service terms. Confirm availability commitments and incident handling in writing.Ask for the vendor's compliance evidence and the responsibility split. Card storage depends on an external service.
Scope check for any modelTest each option with your QSA or internal assessor before you select a model.List every system that stores, processes or transmits card data, including logs, backups and support access.Confirm with your assessor how the chosen model changes the scope boundary and the evidence list.

Build sequence for a self-hosted Hyperswitch card vault

This sequence takes a self-hosted Hyperswitch card vault from design to a documented PCI DSS scope. Each step closes with a check you can run, so gaps surface before live card data reaches the platform. The output is an agreed vault model, a tested deployment and a scope document with a data flow diagram that your assessor can review.

  1. Map card data flows and agree the vault model

    Trace every path a card number takes, from the browser or SDK to the router, the card vault, logs, backups, support tooling and any analytics export. The platform lead and the security lead do this together, and the assessor reviews the draft before build work starts. Choose one of the three documented vault models. The self-hosted, in-house PCI model leaves PCI DSS certification and data handling fully with your organization, which changes staffing and evidence needs from the start. Done when both teams sign off the chosen model and a written list of every data flow.

  2. Check release notes and dependencies for the version

    Read the release notes and dependency requirements for the exact version you plan to run, not the latest one on the releases page. Record the Superposition requirement noted for v1.124.0: a Superposition service must be running before you upgrade to that version, so it belongs in the architecture and the deployment plan. Review the compatibility matrix for Control Center and web client versions. Confirm the PostgreSQL and Redis setup the release expects. Done when a dependency list is approved and every component has a named owner.

  3. Deploy the platform with Helm on Kubernetes

    Follow the self-hosting guide and deploy the router, scheduler, Control Center, PostgreSQL, Redis and the vault services using the published Helm charts on your Kubernetes platform. Start in a non-production cluster that mirrors the production network layout, so later isolation controls can be tested realistically. Keep each component's configuration in version control. Done when every pod reports ready and the router health check passes from inside the cluster.

  4. Isolate the card vault and encryption service

    Place the card vault and the encryption service in a dedicated namespace or network segment. Write network policies so only the router can reach the vault, and block access from the Control Center, other application workloads and any external network. Restrict administrative access to named bastion or jump paths with logging. Done when a connection attempt from an unapproved pod or host fails, and the allowed flows match the data flow list from step one.

  5. Set up key management and document key custody

    Work with the security team to choose how encryption keys are generated, stored, rotated and backed up, using the key management approach your organization has approved. Assign named key custodians and define how key material is split and recovered. Record where each key lives and who can use it. Run a recovery test in a non-production environment. Done when a custody register lists every key, its custodians, its storage location and its rotation owner, and the recovery test result is filed with the scope evidence.

  6. Connect the router to the vault using test cards

    Configure the router to call the card vault and the encryption service, then run the flow only with test card numbers. Use the hosted sandbox or an isolated non-production environment, and make sure no live card number is entered anywhere outside production. Test tokenization, token retrieval and a complete payment, including a declined test card. Done when each test completes as expected and the team confirms in writing that no live card data was used in any non-production environment.

  7. Confirm logs and telemetry contain no card data

    Collect logs, traces and metrics from the router, vault, encryption service, scheduler, PostgreSQL, Redis and your log pipeline. Search them for test card number patterns after successful, declined and error-path payments, because error messages and debug output are common leak points. Confirm that masking and log levels are set as your design requires. Done when repeated searches return no full card numbers and the search queries and results are saved as evidence.

  8. Produce the scope document and data flow diagram

    Write the PCI DSS scope document listing every in-scope system, including the vault, encryption service, router, networks, administrative access paths and logging, along with the reason each out-of-scope system is excluded. Draw the data flow diagram from the approved flows and check it against the scope list. The assessor reviews both before the assessment. DeployOpen can prepare these systems, controls and evidence, but an independent assessor determines the scope outcome. Done when every system on the diagram appears in the scope document, and the reverse is also true.

How each Hyperswitch card vault model moves PCI DSS scope

Under each Hyperswitch vault model, PCI DSS scope follows where card data is captured, stored, transmitted and accessed, so the first task is to decide which model you run and then map the data path it creates. Under the self-hosted, in-house PCI model, the Hyperswitch docs state that the merchant is fully responsible for PCI DSS certification and data handling. In practice the card vault (locker), its encryption service, the cluster hosting both, administrator access paths, application and infrastructure logs, backups and any analytics copies of card data are typically all in scope. Treat each of those as a system to inventory, not as an implementation detail of the vault.

Under a self-hosted orchestration model with an external PCI vault such as VGS or Tokenex, the provider's own compliance evidence generally covers the vault itself. That does not remove your review obligations. The Hyperswitch router, the scheduler, the databases and caches that sit in front of the vault, the client SDK integration, any browser redirects that carry card fields, and every stored token still need to be examined. Ask the provider for its current attestation and a written responsibility matrix, then confirm with your assessor which of your components touch raw card data in transit and which only hold tokens.

Under the SaaS Hyperswitch Vault, your team must confirm in writing exactly what the hosted vault covers, including how card data is received, where it is held and who can access it on the provider side. The self-hosted orchestration you keep running usually remains your responsibility. Check whether any card data passes through your own routers, logs or Control Center sessions before it reaches the hosted vault, and whether your database holds only tokens. Mixed boundaries are where gaps tend to appear, so document the handoff point explicitly.

Scope follows data flows, and the assessor, not the vendor, decides where the boundary sits. Vendor documentation and a vendor's own compliance evidence describe what the vendor controls, but they do not settle what your environment must prove. Before committing to a model, draw the data flow for your chosen vault, from the payment page through the SDK, router, vault, database, logs and backups, and review it with your assessor. Revisit the diagram after each Hyperswitch upgrade or connector change, because new components and new log destinations can move the boundary without anyone intending it.

What drives vault and scope effort, and how to keep it down

This table lists the factors that most change how much work a Hyperswitch card vault deployment and its PCI DSS scope will take, and why each one matters. Each row pairs a driver with one practical way to reduce it, so you can see where scope can be narrowed before any partner quote is requested. Read it as a list of questions to settle early, because most of the effort compounds when several drivers are left open at once.

DriverWhy it moves effortHow to keep it down
Vault modelThe native in-house vault puts PCI DSS certification and card data handling on the merchant, while an external or SaaS vault moves part of that scope to the provider.Decide the vault model before design starts and confirm in writing which PCI DSS responsibilities the provider accepts.
Environments and non-production copiesAny staging, test or analytics copy that holds real card data brings that system into scope and adds evidence work for each one.Use test cards outside production and confirm that database refreshes and backups from production never carry card data into lower environments.
Processor connectors and data pathsEach connector adds a route that card data or tokens may travel, and each route needs its own review of encryption, logging and retention.Enable only the connectors you need at launch and document the data path for each one so the scope map stays current.
Key custody and key ceremony scopeEncryption keys that protect stored card data need documented custody, rotation and ceremony procedures, and every person with key access widens the review.Limit key custodians to a small named group and confirm how the encryption service and key management are isolated from the router.
Administrator and access pathsEvery administrator account, support tool or jump host that can reach the vault or its database is a path an assessor will ask about.Scope admin access to a small group with individual accounts, and route vault access through a single audited path.
Existing PCI DSS program maturityTeams with a working program already have policies, asset inventories and evidence routines, so the new system adds less work than it would for a team starting from zero.Reuse existing policies, scanning and training records, and map the new components onto controls you already run.
Logging and analytics pipelinesLogs, traces and analytics exports can capture card fields or tokens unintentionally, pulling log stores and dashboards into scope.Confirm which fields the router logs, mask or drop card-related fields at source, and limit which teams can query the log platform.
Backup coverageDatabase and vault backups hold the same sensitive data as the live system, so their storage, access and restore procedures must meet the same controls.Keep vault backups in the same protected boundary as the vault, encrypt them, and test restores under the same access rules.
Router customizations touching card fieldsCustom code that reads, transforms or forwards card fields changes the data flow and can place new components in the cardholder data path.Keep customizations away from card fields where possible, and review any change that touches them as a scope change before release.

Securing the card vault and its keys

The card vault and its encryption service hold the data that puts a self-hosted deployment in PCI DSS scope, so their controls matter more than the rest of the stack. The cards below cover the controls specific to the vault, from network paths and key custody to administrator access and log output. General hardening and identity setup are covered on the sibling security and SSO pages.

Limit network paths to the vault

Place the card vault and encryption service in a segment that only the router path can reach, and deny direct access from Control Center, scheduler workers, analytics jobs and developer networks. Confirm the allowed flows with a written list of source, destination, port and protocol. Test the deny rules from each other segment, because a permissive rule added during go-live is a common reason vault traffic scope grows without anyone noticing.

Separate key custody from vault data

Keep the encryption keys managed by the encryption service apart from the vault database and its backups, so that a copy of the data alone cannot be decrypted. Decide who holds key administration rights and who holds database administration rights, and make sure no single operator holds both. Ask your team to confirm where key material is stored, how it is backed up, and how a restore is performed without exposing plaintext card data.

Administrator access through OIDC single sign-on

The Control Center supports single sign-on through OpenID Connect only, so SAML-based identity providers need a separate decision before go-live. Roles are managed inside Hyperswitch rather than mapped from the identity provider, and users must be invited before they can sign in, so access reviews must cover both systems. Confirm which administrators can reach vault-related settings and remove standing access that is no longer needed. Identity setup steps are covered on the Control Center SSO page.

Scope API keys to each service

Issue a separate API key for each service that calls the router, and restrict each key to the operations that service needs. Keep vault-facing keys out of web frontends, batch jobs and reporting tools that never tokenize or detokenize card data. Record an owner and rotation date for every key, and check that a retired service's key is revoked. General secrets handling and rotation practice belong to the security hardening page, so this card covers only key scope.

Encrypt traffic between services

Require TLS on every connection that carries card data or tokens, including router to vault, router to encryption service, and any call to an external PCI vault provider if that model is chosen. Check certificate validity, rotation ownership and whether internal services reject plaintext fallback. Ask your team to document which connections terminate inside the cluster and which cross a network boundary, because the cross-boundary paths are where assessors usually look first.

Keep card data out of logs

Configure log filters so primary account numbers, card verification values and full request bodies from tokenization calls never reach application logs, traces or error reports. Test the filters with synthetic card numbers in every service that handles them, and include Control Center and monitoring exports in the test. Logs are a frequent source of unplanned scope, so treat any log store that receives vault traffic as in scope until a review shows otherwise.

What to monitor, back up and document after go-live

Once the card vault is live, the work that keeps PCI DSS scope stable is operational discipline: monitoring the vault without leaking card data into telemetry, backing up vault data and key material on separate paths, rotating keys on a schedule your policy defines, tracking upstream releases, and keeping scope documentation current. Each of these is a recurring task with a named owner, and each affects what an assessor will ask to see. Monitoring is where scope often gets broken without anyone noticing. The vault service, its database and the encryption service should emit availability, latency and error-rate metrics, but logs, traces and alert payloads must not carry primary account numbers, CVVs or decrypted values. Review the logging configuration of every service that touches the vault, including the Router, the Scheduler and any reverse proxy or service mesh sidecar. Confirm with Hyperswitch which request and response fields are logged at each level, and test the redaction with a synthetic card number before go-live and after every upgrade. Any monitoring tool that stores card values moves into scope. Backups need two separate control paths. Vault database backups hold encrypted card data, so they follow the same access, encryption and retention rules as the live store. Key material belongs on a separate path with separate custodians, so that restoring data never requires the same people or systems that hold the working keys. Rehearse a restore into an isolated environment on a schedule your team sets, and record the result. Key rotation is handled the same way: agree the rotation interval and procedure with your security policy owner, rehearse re-encryption, and log each rotation as evidence. Hyperswitch ships roughly monthly minor releases, and each GitHub release includes a compatibility matrix for the Control Center and web client versions. Assign one person to review each release notes entry for vault, encryption and dependency changes, and for any new required service such as Superposition, which the v1.124.0 release notes describe as a required configuration dependency. Every connector addition or routing change should trigger a documented scope review: does the new processor receive raw card data, does it change the data flow, and does it need its own attestation? Keep three artifacts current: the data flow diagram, the written scope statement and a change log that links each release, connector change or configuration change to its scope review. Assessors expect this evidence to be collected continuously, not assembled before an assessment. Store screenshots, configuration exports, access reviews, restore test records and rotation logs as they happen. Ask your QSA or assessor early which evidence formats they accept.

Vault setup by environment: sandbox, managed Kubernetes and on-premises

Local Docker and Minikube setups let engineers build connectors, test routing logic and exercise the vault API before any production decision is made. They are meant for development only. The scope questions in this topic begin the moment a setup could receive live card data, so the rules for these environments must be written down and enforced.

  • Test card numbers only. Use the test card numbers published for each processor sandbox. Never type a real primary account number into a local form, API call or log.
  • No production data copies. Do not restore production database exports, stored tokens or log files into a local cluster or a shared development namespace.
  • Throwaway keys. Generate separate encryption keys for each development environment and never reuse them in staging or production.
  • Laptops can enter scope. If a developer machine ever handles real card data, your assessor may need to treat it as in scope. Keep it out of that path by policy and by access controls.
  • Hosted sandbox. The vendor documents a hosted sandbox for testing. Use it for integration work, and confirm with the vendor what data it accepts and how it is retained.

Check that local and sandbox setups cannot reach live processor credentials, production databases or production secrets, and include that rule in engineering onboarding.

How to test that the vault works and fails safely

The verification plan has to prove two things: the card vault stores and returns card data correctly, and card data never appears anywhere else in the platform. Run these tests in a non-production environment that matches the production topology, including the Router, the card vault, the encryption service, PostgreSQL and Redis. Start with end-to-end tokenization and payment flows using the test card numbers that your processors and Hyperswitch publish for sandbox use. Confirm that each payment returns a token, that the token can be used for a follow-up payment, and that the Control Center shows only the masked form of the card. Do this for every vault model you plan to run, because the self-hosted in-house model and the external vault models put different systems in the flow.

Next, test the boundaries. Attempt to reach the card vault directly from a pod, host or network segment outside the Router, and confirm that the connection is refused. Then search every place where card data could land: application logs, PostgreSQL tables and replicas, Redis keys and caches, scheduler queue payloads, Control Center exports, support bundles and backups. Use a pattern search for primary account number formats combined with a Luhn check to cut false positives. Expect some matches on test data and on order references, so record how each hit was classified. Ask your assessor early which search method and evidence they will accept, because a search that is documented and repeatable is worth more than a one-time manual grep.

Then simulate failure. Stop the card vault, stop the encryption service and cut network paths between the Router and each one. For each case, confirm that the payment fails with a clear error, that no retry or fallback path writes the card number to a log, a queue, a database row or a cache, and that the merchant-facing response contains no card data. Check the scheduler's retry behavior specifically, since a queued retry that holds raw card data would move the problem into a new system. Record which components were down, how long the failure lasted in your test window and what state the database was left in after recovery. These results show whether the platform fails closed.

Test key rotation and the data flow next. Rotate the encryption keys in the test environment and confirm that tokens stored before rotation still return the correct card data, and that new tokens are written under the new key. Keep old key material available until re-encryption is verified. Then walk your assessor through the current data flow diagram, following a card from the checkout SDK through the Router, the vault and the processor, and pointing out every system that is in scope. Keep the diagram and the test results in one evidence folder. For each test, record the date, environment, Hyperswitch version, tester, expected result, actual result and the location of logs or screenshots. Evidence recorded this way supports the assessment and makes the tests repeatable after each upgrade.

Questions teams ask before building a Hyperswitch card vault

Does the in-house Hyperswitch vault make us fully responsible for PCI DSS?

Yes. The Hyperswitch documentation states that in the self-hosted, in-house PCI model, the merchant is fully responsible for PCI DSS certification and data handling. That statement is the starting point for scoping, not the final answer. Your assessor should confirm exactly which systems, networks, people and processes fall inside the cardholder data environment, including the vault, the router, the database, logs, backups and any non-production copies. Ask for that boundary in writing before the design is frozen, because a change in network placement or logging can move a system in or out of scope. Plan for your organization to own the outcome, even when a partner helps with the build and the evidence.

Does using an external PCI vault remove our PCI DSS scope?

Not automatically. An external vault provider can hold card data and reduce what your own systems store, but scope depends on two things: the provider's evidence of PCI DSS compliance for the specific service you use, and how your team integrates with it. If your self-hosted orchestrator still receives raw card numbers, writes them to logs, or exposes them through internal tooling, those systems can remain in scope. Ask the provider for its current attestation documentation and its responsibility matrix. Then have your assessor review the full data path end to end, including the orchestrator, databases, support tools and any staging environments.

What drives the cost and effort of a self-hosted card vault?

The main drivers are the vault model you choose, the number of environments that need the vault, the number of processors and card flows involved, the depth of the assessment, and how much of the build your internal team can absorb. The implementation plan and cost section of this series explains how each driver changes the work. When you request a quote, ask for one-time work (design, build, hardening and evidence preparation) to be separated from recurring work (upgrades, monitoring, assessment cycles and staff time). Ask the partner to state the assumptions behind each line. Your internal time from payments, security and infrastructure usually sits outside a partner quote and needs its own budget.

How long does it take to build a Hyperswitch card vault for PCI?

There is no single duration that applies to every organization, because the timeline depends on scope and environments. The factors that matter most are the vault model, how many environments need the vault (development, staging, production and disaster recovery), the number of integrations and processors, how mature your network segmentation and logging already are, and how quickly the assessor can review evidence. Ask any partner to show the phases and the dependencies between them, and to identify which milestones depend on decisions or access from your team. Schedule around the assessor's availability, since a delayed assessment window can hold up go-live even when the technical work is complete.

What does our team need to provide for a card vault project?

Expect time from four groups. Payments staff define the processors, card flows, tokenization behavior, refunds and the approach for migrating stored cards. Security staff own policy decisions, key management responsibilities, access control, logging requirements and the review of the cardholder data environment. Infrastructure staff provide the Kubernetes clusters, cloud accounts or data center capacity, network segmentation, database and backup platforms, and the change process. The assessor needs early access to the design, the data flow diagrams and the named evidence owners. Assign one accountable owner per group and agree on how much of each person's time the project will take before work starts.

Can our team build a Hyperswitch card vault without outside help?

Yes, a capable internal team can build and operate a card vault without an outside partner, provided it includes people who have already taken a card environment through a PCI DSS assessment and it can staff the ongoing work. Before deciding, check the following:

  • Someone can map the cardholder data environment and defend the boundary to an assessor.
  • Someone can design and test network isolation, key management and access controls.
  • The team can follow Hyperswitch monthly releases and test upgrades in non-production first.
  • Evidence collection runs continuously, not only in the weeks before an assessment.
  • Leadership accepts that the in-house model places PCI responsibility on your organization.
Will DeployOpen issue a PCI DSS attestation for our vault?

No. DeployOpen does not issue PCI DSS reports, attestations or certifications. Independent assessors and certification bodies do that work. DeployOpen can plan, implement and document a self-hosted Hyperswitch environment inside your own cloud accounts, data centers or air-gapped networks. It can help define the cardholder data environment boundary, configure the controls and prepare systems and evidence so your assessor can review them. The assessor decides the scope and the outcome. Ask any partner to confirm in writing which deliverables serve as evidence for the assessor and which decisions remain with your team or the assessor.

How DeployOpen scopes, builds and hands over a Hyperswitch card vault

DeployOpen plans, implements, hardens and documents self-hosted open-source platforms inside the client's own infrastructure. For a Hyperswitch card vault, we start by fixing which vault model you run, then map the systems that store, process or transmit card data before any build begins. Responsibility for PCI DSS follows that choice, so we document it in writing before the first build decision.

How we scope

  • The written scope names the vault model: native Hyperswitch Vault, external PCI vault or SaaS vault.
  • It lists every system in the cardholder data environment, including the vault, encryption service and key management.
  • Engagements are fixed-scope, with deliverables and timelines agreed in writing before work starts; ongoing support is a retainer.

How we build

  • Deploy Router, Scheduler, PostgreSQL and Redis on Kubernetes using the Helm charts Hyperswitch documents for your cloud.
  • Place the card vault and encryption service in a separate network segment with tightly limited ingress and egress paths.
  • Configure connectors, tokenization flows and Control Center access, then test card capture end to end in a non-production environment.

How we hand over

  • A data flow diagram showing where card data enters, is tokenized, stored and leaves the environment.
  • A responsibility matrix assigning each PCI DSS control area to your team or the vault provider.
  • Runbooks for deployment, key rotation, backup and restore, plus an evidence list for your independent assessor.

How we support

  • Review each monthly Hyperswitch release against the compatibility matrix for Control Center and client SDKs before upgrading.
  • Check new required dependencies, such as Superposition, and database migrations in staging before any production change.
  • Refresh scope documentation and PCI evidence after changes to the vault model, connectors or network boundaries.

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.