Architecture
High-Level Architecture
Dynamic TLS/SSL Pinning is part of the Mobile In-App Protection product. It can also be delivered separately as a standalone product. The deployment of the backend can be either on-premise or in SaaS mode.
The product consists of two parts:
- Mobile Utility Server
- Native SDKs for iOS and Android

Technical Architecture

The mobile app with the integrated Pinning SDK downloads the signed list of certificate fingerprints from the Mobile Utility Server via the REST Device API. The app then uses the list to pin the HTTPS connections to the business APIs.
The Device API is the only part of the server that is exposed to the public internet. The administration of the server is available only from the internal network, either via the In-App Protection Console or via the REST Integration API. The Mobile Utility Server stores its data in an SQL database and connects to it via JDBC over TLS.
Mobile Utility Server
The Mobile Utility Server is the backend component that manages applications, pinned domains, and trusted certificates. It signs certificate fingerprints with a private key and publishes them for the mobile SDKs, allowing trusted certificates to be updated without releasing a new version of the mobile app.
The Mobile Utility Server is delivered as an Open Container Initiative (OCI)-compatible container image. The solution is cloud agnostic and can be deployed on-premises or in public or private cloud environments.
Native SDKs
The native SDKs for iOS and Android integrate certificate pinning into the mobile app. They download the certificate fingerprints from the Mobile Utility Server, verify the signature using the public key embedded in the app, and check server certificates against the trusted fingerprints when establishing TLS connections.
Firewall
The firewall controls traffic between the public internet and the internal network, protecting the exposed service endpoints.
For SaaS deployments, a content delivery network (CDN) with distributed denial-of-service (DDoS) protection and web application firewall (WAF) capabilities protects the public-facing Mobile Utility Server endpoints. For on-premises deployments, we expect integration with the customer’s existing network infrastructure, including its firewalls and access-control policies.
Integration Capabilities
The Mobile Utility Server provides REST APIs over HTTPS for mobile clients, administration, and integration with existing systems.
| API | Consumer | Description |
|---|---|---|
| Device API | Pinning SDK | A public API that provides the signed list of certificate fingerprints to the mobile app. |
| Integration API | Customer systems (e.g., key management infrastructure) | An authenticated API for automating the certificate lifecycle, such as registering a renewed certificate or removing expired ones. It should be exposed only in trusted networks. |
| Console API | In-App Protection Console | An API used by the console web UI to manage applications, domains, and certificates. |
Expose the Device API endpoint on a separate hostname, distinct from the hosts protected by pinning. This allows the SDK to retrieve and refresh certificate fingerprints regardless of the cache state, particularly during first initialization, when no fingerprints are cached. Keep this connection independent of dynamic pinning while retaining standard TLS certificate validation.
Observability
The Mobile Utility Server can be monitored using standard tools such as Prometheus. Runtime and application metrics help track resource utilization, request rates, errors, and response times.
Application performance monitoring (APM) and distributed tracing can be integrated with the organization’s preferred APM tool using standard instrumentation, including OpenTelemetry (OTEL). OpenTelemetry enables vendor-neutral telemetry collection and export to compatible monitoring platforms.
The server produces structured application logs that can be forwarded to a centralized logging platform. Logs can be exported via OpenTelemetry or collected from the container’s standard output (stdout) using a log collector or forwarding agent. This allows integration with existing logging infrastructure without requiring a product-specific logging backend.
Reliability and Scalability
Scalability
The initial deployment is sized for normal traffic and expected peaks in certificate fingerprint downloads. Container orchestration platforms can automatically scale the application layer horizontally based on traffic and resource utilization to accommodate unexpected increases in load.
The Mobile Utility Server is fully horizontally scalable by adding instances behind a load balancer.
The database layer is sized separately, with enough performance headroom for peak traffic and the chosen High Availability and Disaster Recovery configuration.
Based on monitoring and expected growth in mobile app usage, application and database resources can also be scaled vertically to maintain a stable quality of service.
Reliability
Dynamic TLS/SSL Pinning supports High Availability (HA) and Disaster Recovery (DR). Redundant Mobile Utility Server nodes, a highly available database, and reliable connectivity between deployment sites support continuity and recovery during infrastructure outages.
System Requirements
Application Layer
We recommend running 2–3 nodes of the Mobile Utility Server to achieve high availability. Each node requires:
| Resource | Requirement |
|---|---|
| CPU | 2× core, 2.0 GHz |
| Memory | 4 GB free RAM |
| Disk Size | 2 GB free disk space |
Database Layer
The Mobile Utility Server requires an SQL database. The following databases are supported:
- PostgreSQL
- Oracle
- Microsoft SQL Server (MSSQL)
The database server requires:
| Resource | Requirement |
|---|---|
| CPU | 2× core, 2.0 GHz |
| Memory | 4 GB free RAM |
| Disk Size | 25 GB free disk space |
| Storage I/O performance | At least 100 IOPS (input/output operations per second) during peak load |
Validate storage performance with the expected database workload; achievable IOPS depend on I/O size, read/write mix, and storage latency.