Introduction
While Post-Quantum cryptography is discussed as a security challenge, looking down to implementations and trials you can see It is equally a delivery and capacity planning challenge.
The Security part is settled with the entities responsible for evaluating and deciding the standards leading this effort. NIST finalized the core standards in August 2024. Libraries shipped, browsers shipped, and by late 2025 the majority of human-initiated traffic reaching large CDNs was already protected by post-quantum key hybrid agreement up from roughly 2% in early 2024. The hard part is no longer which algorithm but how to get it to practice and production environment.
In this article we explore three angles of the post-quantum challenges
- Crypto-agility is the architectural goal, while ML-KEM is the current answer but it’s not the final one.
- TLS 1.3 is the entry gate, and it has its own CPU bill. The path to Hybrid or pure PQC implementation starts with TLS1.2 to TLS1.3 migration.
- The real impact is in the handshake CPU and bytes not the throughput. With bulk encryption is untouched, this simple distinction changes where you look for bottlenecks.
Crypto-agility is the actual deliverable
If you are following crypto related changes over time, it started with SSLv2 to SSLv3, then TLS came to the picture then the move from TLS1.1 to TLS1.2 and now TLS1.3 then. If each requires a release cycle per application, every update is an intensive migration activity with resources and time.
Not just the transitions till TLS1.3, even with the rise of PQC adoption the approved ciphers kept changing. For example, SIKE, a NIST alternate finalist, was broken in 2022 by a classical attack running in under an hour on one core. Rainbow fell similarly. The current ML-KEM and ML-DSA rest on lattice assumptions roughly twenty years old, so it’s fair to assume new algorithms to rise and others to fade.
Crypto-agility gives us the ability to change algorithms, parameters and key sizes through configuration and policy not code changes, recompilation, or hardware replacement.
How to realize if your system is an actual crypto-agile system:
- Ability to change algorithms and work with different algorithms at the same time.
- Ability to handle the changing sizes of the algorithms
- Centralized policy and automated certificate lifecycle.
- Few, well-known termination points are a must upgrade point. Converging TLS termination onto a managed tier cuts the migration surface from thousands of endpoints to tens.
- Known inventory with a CBOM covering every algorithm, key, certificate and protocol version.
PQC starts at TLS 1.3 - and TLS 1.3 is not free
It’s always TLS1.3 with PQC not TLS1.2 and that’s due to TLS 1.3 (RFC 8446) treats a KEM as just another named group in supported_groups/key_share and the hybrid construction concatenates classical and PQC shared secrets into the key schedule, so the session is secure if either holds.
What TLS 1.3 itself costs
While there are savings for example, one round trip instead of two, and a simpler state machine.
It comes with costs, in TLS 1.3 forward secrecy is mandatory, so if you ran static-RSA suites every handshake now does an ephemeral key agreement; the key schedule runs more HKDF than TLS 1.2.
TLS 1.3 tickets are single-use by default for anti-replay, so direct and unplanned migration from TLS 1.2 can collapse your resumption rate, converting cheap resumptions into expensive full handshakes.
So where does the cost come from when going Hybrid PQC ?
- We are doing both Hybrid CPU = classical + PQC. We are adding load not replacing the efforts.
- Roughly 60-80% of ML-KEM time is SHAKE-128/256 (Secure Hash Algorithm KEccak) for matrix expansion and sampling. The hardware gap here is that x86 SHA-NI (SHA New Instructions) accelerates SHA-1 and SHA-256 - not SHA-3. As you see, PQC is architecture-sensitive in a way RSA and ECC never were; your ARM and x86 fleets will not show the same regression.
- Larger working set. Kilobyte-scale polynomial matrices versus 32-byte scalars means cache pressure, which at high concurrency degrades co-resident workloads - something single-threaded benchmarks miss entirely.
The network cost
The network cost of PQC adoption is larger, operationally disruptive, and far less discussed.
Authentication is where the real damage is, let’s follow a practical example to feel the numbers, a two-tier chain leaf and intermediate public keys, two certificate signatures, plus CertificateVerify running ~1.5–2 KB with ECDSA P-256 versus ~14–16 KB with ML-DSA-65, add OCSP stapling and CT SCTs, themselves signed, and a fully-PQC handshake approaches 20 KB against 3–5 KB today, that’s a 4–7x increase.
Packet-level consequences
A ~1,200-byte key share pushes ClientHello past one MTU once SNI, ALPN, extensions and GREASE are included.
- TCP: On a lossy path ClientHello segments losing either costs a retransmission timeout before the handshake starts.
- QUIC: The anti-amplification limit caps the server at 3x bytes received before address validation, and a large server flight can trip it.
- Middleboxes: Some inspection devices and older proxies have hard-coded ClientHello size limits or assume a single segment.
This means the need for TCP optimization and middleboxes those can translate not just protocols and ciphers but also the different network bandwidth across both client and server for the applications and transient inspection devices.
The most user-visible effect is congestion control, not cryptography:
Bandwidth calculations
At 50,000 new TLS connections/sec a classical using ~4 KB/handshake is ~1.6 Gbps of handshake traffic; hybrid KEX only ~5.5 KB is ~2.2 Gbps; full PQC auth ~18 KB is ~7.2 Gbps. That’s additional 7.2 Gbps for every 50k connections.
Hardware must absorb a new cryptographic load
The most under-appreciated area, and the longest lead time.
Enterprise estates are full of hardware that accelerates RSA and ECC for example, QuickAssist-class accelerators, SmartNICs and DPUs, cloud offload engines, network and PCIe HSMs, TPMs and secure elements, ADC-integrated SSL hardware.
Current firmware support for FIPS 203/204 is uneven, and some older models will never get it because the FPGA or ASIC cannot be reprogrammed for lattice arithmetic.
PKCS#11 and KMIP needed extension for PQC key types; confirm your KMS, HSM and client library versions align. Stateful hash-based signatures (LMS/XMSS) require strict state management, since reusing a one-time key is catastrophic, the HSM must enforce state and your design must never clone signing state.
Conclusions
- Crypto-agility is the durable deliverable. NIST’s selection of HQC as a lattice-independent backup is an institutional admission of that.
- TLS 1.3 is the gate, and it has its own bill. Measure coverage first, fix resumption before layering PQC on top.
- The cost lands on handshakes, not throughput. Exposure is proportional to connections-per-second, not bits-per-second.
- Hardware is the long-lead item, and the accelerator is the hidden cost
- Network cost exceeds CPU cost in operational disruption. Handshake bytes grow 4–7x, with real congestion-window, MTU and middlebox consequences. Phase key exchange separately from authentication.



