GartnerMongoDB named a Leader in the 2026 Gartner® Magic Quadrant™ for Cloud Databases. Read the Gartner report > >>

How to Align Modern Payment Platforms with PCI DSS Using MongoDB Enterprise Advanced

November 19, 2026 ・ 6 min read

Payment platforms operate in a demanding environment. They must protect payment account data and support the teams that authorize transactions, investigate suspicious activity, and resolve exceptions. The more people and systems that can see sensitive data, the harder it is to control exposure. And the more data is locked away, the harder it can be to use in legitimate workflows. So how can you set up the platforms to ensure they protect that data while also giving the right people access?

Payment Card Industry Data Security Standard (PCI DSS), a global security standard managed by the PCI Security Standards Council, provides a framework for protecting payment account data, restricting access, securing networks, and monitoring activity. Meeting those objectives is not a database-only exercise. It depends on how the application handles data, how the database server protects and governs it, and how the underlying infrastructure is configured and operated.

While the fully managed MongoDB Atlas platform can provide a foundation for organizations pursuing PCI DSS compliance, with MongoDB’s infrastructure-level certifications supporting the infrastructure layer, some organizations opt for a self-managed architecture to maintain direct operational control over their infrastructure and internal security policies. For self-managed deployments, MongoDB Enterprise Advanced provides database security, governance, and encryption capabilities that can help support applicable PCI DSS objectives. Red Hat OpenShift provides configurable platform and network controls, while the MongoDB Controllers for Kubernetes (MCK) Operator manages MongoDB deployments on OpenShift.

Achieving alignment across this architecture requires a defense-in-depth model, which provides multiple overlapping layers of cybersecurity to protect data. While technical controls and reference architectures alone do not constitute formal compliance attestations, they provide the foundation needed to meet core PCI DSS objectives. The following sections walk through establishing this foundation across three complementary tiers—application, database, and infrastructure—before examining how they work together to protect sensitive payment workflows.

Start with the application layer

The application determines what payment data enters the platform, where it flows, and which business roles need it. In our reference payment service provider (PSP) demo, the application models two distinct workloads: high-throughput payment authorizations and post-transaction fraud investigations.  

This PSP demo application is designed to support deployment with either a fully managed MongoDB Atlas cluster or a self-managed MongoDB Enterprise Advanced deployment. Its core architecture, data models, and client-side encryption approach can be shared across both models, although configuration, integrations, and operational responsibilities may differ by environment. This dual compatibility gives organizations the flexibility to migrate workloads between cloud and on-premises environments as strategic needs evolve, eliminating infrastructure lock-in. Furthermore, it reinforces data sovereignty by allowing organizations to retain direct operational control over where cardholder data resides and how it is governed across hybrid architectures.

At the functional level, data minimization is enforced at the point of entry. Primary account numbers (PAN) are tokenized when downstream services do not need raw cardholder data, and sensitive authentication data (SAD) such as card verification value (CVV) never gets stored post-authorization. In addition, an isolated application programming interface (API) layer ensures that external clients never connect directly to the database tier.

These design choices reduce unnecessary exposure before data reaches storage. They also make the next layer more effective: The database can apply protection to the fields and workflows that genuinely need it, rather than compensating for an application that collects or shares too much.

Protect and govern data at the database layer

MongoDB Enterprise Advanced provides security capabilities for self-managed MongoDB deployments. One relevant capability is queryable encryption (QE). It allows selected fields to remain encrypted in the database while supporting defined query patterns over those fields. In practical terms, an authorized payment or investigation workflow can look up protected information, such as an account reference, without the database storing that value in plaintext. The client driver encrypts selected fields and decrypts query results using keys from the configured key management service (KMS), meaning the database engine processes only ciphertext for supported query patterns. QE is field- and query-specific, so teams can choose which data must be searchable and validate the supported patterns for their deployment.

Encryption works alongside access governance. MongoDB role-based access control lets administrators assign built-in or custom roles so that application services, analysts, auditors, and database operators receive only the permissions they need. MongoDB also supports IP-based authentication restrictions for database users. These controls help answer two different questions:

  • What may this identity do? 

  • From which network locations may it connect?

Database auditing can complement these protections by recording selected database activity for review and investigation. The value comes from connecting audit policy to the organization’s monitoring and response processes, not simply turning on logging in isolation.

Enforce the environment at the infrastructure layer

The database and application still need a tightly controlled environment. OpenShift provides platform controls that teams can configure to isolate workloads and govern their runtime. Those controls include role-based access for cluster and project operations, security context constraints for pod privileges, and NetworkPolicies to limit which workloads can communicate. For example, a policy can allow the payment API to reach MongoDB while denying unrelated workloads access to the database network path.

The MongoDB controllers for Kubernetes (MCK) operator manages the cluster’s deployment, while Ops Manager provides management capabilities such as automation, monitoring, and backup according to the deployment configuration. These tools help platform and database teams operate the deployment consistently; they do not replace the need to set restrictive policies, manage identities and keys, or review the resulting configuration.

The following high-level view shows how the layers work together:

Figure 1. Payment platform stack, from underlying infrastructure to business applications. 

Diagram illustrating the six layers of the payment platform stack, from bottom to top: Layer 0 Underlying Infrastructure, Layer 1 Operating System (RHEL OS), Layer 2 Container Platform (OpenShift), Layer 3 Persistence (MongoDB Controllers for Kubernetes Operator), Layer 4 Data Orchestration & Automation (MongoDB Ops Manager), and Layer 5 Business Applications (PSP, ASPSP, and External IdP).

As shown above, these components align into a defense-in-depth model. The stack builds upward from the host infrastructure and immutable operating system (RHEL OS) to the OpenShift container platform, establishing a hardened foundation. On top of this platform, the MCK operator provides persistence for the encrypted data, Ops Manager orchestrates data automation, and the business payment microservices run isolated at the application tier. This layered view helps teams map controls across each tier to meet PCI DSS requirements.

How the layers support PCI DSS objectives

Application-level tokenization and data minimization can reduce how much sensitive data the platform handles. Queryable encryption can protect selected fields while preserving supported lookup workflows. Database roles and IP restrictions can narrow access to the database, while OpenShift policies can further limit which workloads and network paths reach it. Auditing and operational monitoring help teams review activity and investigate events. The value, ultimately, occurs when this all comes together seamlessly.

As illustrated in Figure 2, the reference PSP demo organizes these controls into clear architectural boundaries:

  • Perimeter and access control: External entities (client devices, wallet systems, and merchant systems) communicate exclusively over HTTPS through the service gateway. Identity and access policies are enforced at the security gateway using standards such as OAuth, OIDC, and JWT backed by general identity and access management (GIAM), preventing direct access to data stores from untrusted networks.

  • Protected core processing: The core system coordinates payment workflows and integrates directly with a key management service (such as AWS KMS) and MongoDB EA. This design ensures that field encryption occurs before persistence and that the database engine handles only ciphertext for configured search patterns.

  • Event decoupling and specialized services: By routing events through an event bus (Kafka) to dedicated providers for fraud detection (FDS) and anti-money laundering (AML), the platform isolates investigative workflows from the core payment engine, supporting workload separation and least-privilege data access.

Figure 2. Reference view of a PCI DSS-aligned payment demo integrated with MongoDB Enterprise Advanced on OpenShift.

Architecture diagram showing the reference view of a PCI DSS-aligned payment demo integrated with MongoDB Enterprise Advanced on OpenShift. The central Payment Service Provider (PSP) contains a dashboard, service and security gateways, core system, event bus, and providers layer (FDS, AML, KYC, KYB, AIS, PIS). It connects externally to client devices, wallet systems, merchant systems, GIAM, MongoDB Enterprise Advanced, AWS KMS, Kafka, and specialized external systems for investigation, identity, and open banking.

Together, these controls can support PCI DSS objectives such as protecting stored account data, restricting access based on business need, maintaining secure network boundaries, and monitoring access. With a self-managed MongoDB EA deployment on OpenShift, the organization remains responsible for the full cardholder data environment, including infrastructure configuration, identity and key management, operational procedures, and evidence.

The payment service demo application makes this layered approach tangible. Its payment and investigation workflows provide concrete context for demonstrating how queryable encryption can protect selected sensitive fields while supporting defined searches, how MongoDB roles and IP-based restrictions narrow database access, and how OpenShift policies can limit paths between the application and data tiers. MCK and the Ops Manager provide deployment and operational tooling for sensitive data, tailored to the organization’s needs. These layers offer a starting point for building a self-managed payment environment with controls across the stack.

megaphone
Next Steps

To see this approach in practice, explore the PCI DSS-aligned payment reference implementation and the MongoDB Controllers for Kubernetes OpenShift guidance. 

The takeaway is straightforward: MongoDB Enterprise Advanced, MCK, and OpenShift can provide a practical foundation for running a payment application on infrastructure the same organization controls.

MongoDB Resources