We are approaching a paradigm shift that will redefine the boundaries of computing power. Quantum computing is not just a faster version of what we have; it is a fundamental rewrite of how we process information. Because of this, the digital world as we know it is built on assumptions that these machines are about to dismantle – marking a quiet countdown toward the quantum era beneath the surface of modern cryptography.
For decades, quantum computers have been perceived as some futuristic technology with very small chances of ever becoming a reality. But this position is becoming harder to defend today. Recent technical advances are bringing closer the capabilities that a fault-tolerant quantum computer would need. The field is meeting important milestones, and there are teams with feasible roadmaps to build more reliable machines in the 2030s.
This does not mean that a cryptographically relevant quantum computer (CRQC) is imminent, but we can already see the symptoms of a plausible development path towards one. That uncertainty is precisely why preparation has to begin before the threat arrives, and clear guidelines need to be adopted by companies, governments and standards bodies to seamlessly make the switch.
The goal of this blog post is to serve as a friendly guide to navigating both the problems and solutions of this emerging quantum reality.
Qubit by bit - Setting the measuring stick
Before we even try to understand what a qubit means, it’s important that we understand what a classical bit of information is. At the software level, bits are binary states, either 0 or 1. At the physical level, however, it’s the representation of a system that can be off or on reliably. For example, in a modern transistor, bits correspond to a low or high voltage signal passing through them, and slight variations in range do not flip their interpretation.
This binary abstraction is what makes the foundation for classical computing. Once information has been reduced to stable zeroes and ones, logic gates can combine them predictably and memory can store them without losses. While this framework still powers all modern digital infrastructure, quantum computing demands a fundamental shift: replacing these discrete switches with qubits.
When we talk about qubits, we are referring to the bit “equivalent” inside a quantum computer. There are also two distinguished states, named |0> and |1>. But unlike a classical bit, a qubit can exist in a quantum state that combines both basis states as
where alpha and beta are called amplitudes, which behave like the coordinates of a vector in a bidimensional space:
For valid, normalized quantum states represented by a unit vector – meaning that the hypotenuse |ψ> has length one) – our good old friend Pythagoras tells us that its squared components must add up to one:
That is to say, |α|² and |β|² represent the probabilities that the observed value of the qubit is in the |0> state or the |1> state each. This happens because the qubit is both in the |0> and |1> states at once, but measuring it collapses its fluid reality down to a discrete binary value.
This nuance is the key distinction between the familiar bit, and this awkward novel intruder: the qubit. It’s not about a bit that is somewhere in-between off and on, it’s a bit that is in all of the infinite continuous amplitudes and phases at the same time. Quantum algorithms are powerful because they manipulate these amplitudes before the final measurement.
Physically speaking, there is no single universal object that encodes qubits. Qubits’ behavior can be obtained from several systems such as spin states of an electron or polarization of a photon. Engineers build quantum computers by isolating these particles well enough from environmental noise so their amplitudes and phases can be reliable to be used in practice.
Beyond intuition - Understanding the quantum phenomena
The identity dilemma of qubits is not the only mind-blowing piece we need to grasp the powers of quantum. There are three other main ingredients that can be stirred together to extract umami from qubits.
- Superposition: Unlike a classical register of n bits, which represents one of the
2ⁿpossible bit strings at a time, a quantum one can be prepared in superposition of all the2ⁿbasis states. Algorithms running in superposition of states are exponentially faster than their classical counterparts because it executes every answer simultaneously. The actual challenge is to arrange computation so that useful possibilities become more likely to be measured at the end. - Interference: Quantum amplitudes behave in some ways like waves. Imagine a room full of instruments playing without coordination. Sound waves can reinforce one another by turning up their volume, or cancel one another with noise, and quantum circuits exploit this interference deliberately. This way, paths associated with unwanted answers can be destroyed whereas useful structures can increase their probabilities. Quantum programming takes care of arranging their phases so that the right melody can get heard.
- Entanglement: Qubits are entangled when they share the same quantum joint state. Meaning that they will always produce matching results, and this correlation remains even when they are far away from each other. This is not to say that A is a copy of B, they simply cannot be expressed as two independent qubit states. Because calling it teleportation sounded too sci-fi to be taken seriously.
Of course, there is a downside to all of this. Fragility is the price to pay for these quantum dishes. These states are so sensitive to noise and interaction from outside factors that quantum gates are imperfect. Measurements make mistakes. And at the end, we only get to witness the outcome of a dice roll.
This is why headlines focusing only on physical qubits miss the point; thousands of them are still not sufficient to overturn systems’ security. What cryptography actually requires is an equally significant number of stable, logical qubits created through error correction – a milestone that remains one of the field's biggest engineering challenges.
Two rings to risk them all - Breaking cryptography foundations
Despite gigantic efforts in quantum craftsmanship, the two well-known pioneer algorithms keep leading the threat. Forged decades before the hardware to run them even existed, these two mathematical blueprints hold the key to overturning our security architecture. One targets the very foundations of public-key cryptography, while the other relentlessly accelerates the decay of our symmetric standards.
Grover’s Algorithm
Grover accelerates brute-force search, which usually reduces security margins by its square root. If you’re familiar with the birthday paradox, then you know that there is a very high probability of finding two people with the same birthday in a room of just 20 people, which is roughly the square root of 366 (the total number of dates). This is why the security level against hash collision, aka finding two preimages resulting in the same length-N hash digest, is √N in the classical world. Now in quantum, the problem that also receives quadratic speedup is hash pre-image finding. In the room above, it’s the equivalent of finding a person with a specific birthday. Grover’s algorithm achieves it through a technique called amplitude amplification. First it prepares a superposition over possible answers, and marks the amplitude associated with a valid answer by changing its phase. Then it applies an interference step increasing the marked amplitude. This is repeated several times until the measurement is likely to return the target. Essentially in a dark warehouse, it would repeatedly reshape the probability scenario until the right box you’re looking for is brighter than the rest.
Shor’s Algorithm
Shor attacks the mathematical structure beneath the assumed hard one-way functions (OWF) found in the vast majority of public-key cryptosystems, making them virtually unusable.Most asymmetric encryption schemes are built upon the assumption that some problems are fast and easy to compute in one direction, but really hard to revert. Some of those are integer multiplication versus prime factoring decomposition, and scalar multiplication versus elliptic curve discrete logarithm. These are the OWF behind widely spread schemes such as RSA and ECDSA, respectively. Shor’s algorithm is capable of transforming these functions into period-finding problems. A quantum computer can prepare a superposition of many inputs, evaluate a periodic function across them, and use interference—through the quantum Fourier transform—to make information about the hidden period observable. This provides an exponential speedup over known classical algorithms, making these systems obsolete in a quantum scenario.
Phase shift – Manipulating the present
The threat may be quantum, but most of the preparation required now is classical engineering. We do not need to wait for a cryptographically relevant quantum computer to begin protecting systems from one. Post-quantum cryptography can actually run on conventional hardware, giving us a window in which vulnerable foundations can be identified, replaced, and tested before migration becomes an emergency.
We cannot control when large-scale quantum computers will arrive, but we can already account for their potential impact. What we build today will determine how we withstand that moment. Preparing for it begins with an uncomfortable act of exposure: mapping every dependency on structures that quantum algorithms could unravel. And that map must descend beneath the visible surface—into TLS, VPNs, certificates, code signing, HSMs, encrypted backups, wallets, validators, bridges, and zero-knowledge systems—because the least maintained wall is the one most likely to collapse first.
The most unsettling threat is not sudden collapse, but delayed revelation. In a harvest now, decrypt later scenario, nothing appears broken so far: data flows, systems operate, and secrets remain sealed. Meanwhile, copies of that encrypted information may be accumulating in adversarial vaults, waiting for a future key that does not yet exist. When Pandora’s box is eventually opened, the breach will not be a single event but a retrospective: years of communications, transactions, and decisions unveiled at once. Updating encryption at that point will only protect what comes next; it cannot retract ciphertexts recorded in the past. This creates a quiet hierarchy of risk: some data fades quickly, but long-lived secrets from medical histories, state secrets, intellectual property, wallet backups, and institutional transactions must remain confidential across decades, and are on borrowed time.
Luckily, the broad directions of this journey can start to take shape:
These replacements are not drop-in equivalents. Larger keys and signatures can increase bandwidth, storage, hardware-wallet requirements, and transaction fees, while new implementations remain exposed to timing leaks, weak randomness, and side-channel attacks. Migration must therefore evaluate not only mathematical security, but also implementation quality and operational cost.
Transition should initially use hybrid modes, for example, pairing a classical key exchange with a post-quantum scheme in the same handshake, so an attacker must defeat both components. But hybrid deployment is only the first step. The deeper objective is crypto-agility: algorithms, keys, and transaction formats must be versioned and replaceable, because no scheme chosen today should be treated as permanent. Standards may evolve, attacks may improve and implementations may fail. Our strongest defense is therefore not one supposedly final algorithm, but an architecture capable of recognizing weak foundations and replacing them before an adversary forces the decision.
For blockchain networks, this transition is particularly delicate because cryptographic choices become shared consensus rules. Users may need new address formats, exchanges and wallets must support them, validators may require new signing and aggregation mechanisms, and dormant funds may remain under vulnerable public keys for years. A safe migration will probably be staged: opt-in post-quantum accounts first, hybrid authorization for high-value operations, and only later, a protocol-wide change of defaults.
But identifying that path is only the beginning. How cryptography, blockchain protocols and the infrastructure surrounding them can execute such a migration – without fragmenting networks, locking out users or weakening security along the way – is a much deeper conversation for another day.
Today, our systems exist in a quantum state: secure and endangered at once. Only a measurement taken years from now will tell us which reality we were building toward.