What Is Quantum Computing? A Beginner's Guide From Bits to Qubits

For the last few years almost every technology conversation has been about AI. Quietly, in the background, a second technology has been moving from physics labs into cloud data centres: quantum computing. IBM, Google, Microsoft, Amazon and a long list of start-ups now let anyone run programs on real quantum hardware over the internet, and governments are already telling organisations to prepare their encryption for it.

Most explanations of quantum computing go one of two ways. Either they open with pages of linear algebra, or they say "a qubit is 0 and 1 at the same time" and stop there. The first loses most readers in a paragraph. The second sounds exciting but leaves you with a picture that's not quite right, and that breaks down the moment you try to understand what a quantum computer is actually good at.

This post takes a middle path. No heavy mathematics, but no hand-waving either. By the end you'll know what a qubit really is, what superposition, measurement and entanglement mean, how quantum gates and circuits work, and you'll have run (or at least read) your first quantum circuit.

Start With What You Already Know: The Classical Bit

Every computer you have ever used, from your phone to the largest cloud server, is a classical computer. Underneath everything (apps, videos, AI models) it works with bits.

A bit has exactly two possible values: 0 or 1. Physically, that might be a tiny transistor that is either off or on, a spot on a disk magnetised one way or the other, or a pulse of light that is either there or not.

The easiest picture is a coin lying on a table:

• It shows either heads (call it 0) or tails (call it 1).
• You can look at it as often as you like. Looking doesn't change it.
• You can photocopy the result and give it to a friend. Copying is free and perfect.

Put several bits together and you can represent bigger things. Three bits can hold any one of 8 patterns (000, 001, 010, 011, 100, 101, 110, 111). The important word is one: at any moment, those three bits hold exactly one of the eight patterns, and nothing else.

A classical computer changes bits with logic gates such as AND, OR and NOT. Billions of these gates, switching billions of times per second, are what run every program you use.

Everything about a quantum computer is easiest to understand as "what changes compared with this."

Meet the Qubit

A quantum computer works with qubits (short for quantum bits). Like a bit, a qubit has two basic states, written |0⟩ and |1⟩. The odd bracket is called a "ket" and is just physicists' notation for "the quantum state called 0". You can read |0⟩ as "zero" and |1⟩ as "one".

The difference is what a qubit can do between those two states.

A qubit is a quantum state that can be represented as a combination of the |0⟩ and |1⟩ states, until it is measured. That combination is called a superposition. Written down, the general state of one qubit looks like this:

state = a × |0⟩  +  b × |1⟩
 
a and b are called amplitudes.
The chance of measuring 0 is |a|²
The chance of measuring 1 is |b|²
The two chances always add up to 1 (100%).

You don't need to calculate anything with this. Just notice three things:

1. A qubit's state is described by two numbers (the amplitudes a and b), not one value.
2. Those numbers decide the probability of what you will see when you look.
3. Amplitudes are not ordinary probabilities. They can be negative (and, more generally, complex numbers). Hold on to that, because it turns out to be the whole secret.

Physically, a qubit can be many things: a tiny superconducting circuit cooled close to absolute zero (IBM, Google), a single charged atom held in place by electric fields (Quantinuum, IonQ), a neutral atom held by laser light (QuEra, Pasqal), or a particle of light (PsiQuantum). They all behave according to the same rules described in this post.

Superposition: The Spinning Coin

Here is the usual analogy, and it's a good place to start.

A classical bit is a coin lying on the table. It's heads or tails, full stop.

A qubit is like a coin spinning in the air. While it spins, it isn't showing heads or tails. It's in a state that involves both. Only when it lands (when you measure it) do you get a definite heads or tails.

An equal superposition, where a and b are the same size, is like a fair spinning coin: when it lands, you get 0 half the time and 1 half the time. An unequal superposition is like a weighted coin: it might land on 0 ninety percent of the time.

Why "0 and 1 at the same time" is only half the story

You will often read that "a qubit is 0 and 1 at the same time." As a first picture, that's useful. As a technical explanation, it's misleading in three important ways, and understanding them is what separates real understanding from buzzwords.

1. It is not secretly holding two answers you can read. If a qubit "really" held both values, you would expect to be able to read both. You can't. When you measure a qubit, you get exactly one bit back: 0 or 1. The superposition is gone. With n qubits the state is described by 2ⁿ amplitudes (300 qubits involve more amplitudes than there are atoms in the observable universe), but measuring them still gives you only n ordinary bits. A quantum computer cannot simply "try every answer at once and hand you all the results."

2. The amplitudes can cancel each other out. Probabilities are always positive, so they can only add up. Amplitudes can be positive or negative, so two paths leading to the same answer can cancel (destructive interference) or reinforce (constructive interference). This is the real source of quantum computing's power, and it has no equivalent in "0 and 1 at the same time." More on this below.

3. Even the spinning coin is not quite right. A real spinning coin is, at every instant, in some definite physical position. We just don't know which way it will land. A qubit in superposition is not hiding a definite answer we don't know yet. The 0 or 1 genuinely doesn't exist until measurement produces it. That sounds strange, and it is. It's also one of the most precisely tested facts in all of physics.

Measurement: When the Coin Lands

Measurement is the act of reading a qubit, and it is where quantum and classical behaviour meet.

When you measure a qubit:

• You always get a classical result: 0 or 1. Never "both", never "0.5".
• Which result you get is random, with the chances set by the amplitudes.
• The superposition is destroyed. After measurement, the qubit is simply in the state you saw. Measure it again straight away and you get the same answer.

This has a very practical consequence for how quantum programs run. Because one run gives you one random sample, a quantum program is usually run hundreds or thousands of times. Each run is called a shot, and the result is a count of how often each answer appeared.

For a single qubit in an equal superposition, 1,000 shots might give you something like:

Result   Count
0        507
1        493

Not exactly 500 each, just as 1,000 real coin flips wouldn't be. The pattern across many shots is the answer, not any single run.

There is one more rule worth knowing now: you cannot copy an unknown quantum state. This is called the no-cloning theorem. The coin on the table can be photocopied; the spinning coin cannot. It sounds like an inconvenience, and for programmers it is. For security it turns out to be a feature, which a later post in this series will come back to.

Interference: The Real Secret

If measurement only ever gives one random answer, how can a quantum computer be useful at all? The answer is interference, the idea from point 2 above.

You have already used interference if you own noise-cancelling headphones. They play a sound wave that is the exact opposite of the background noise. The two waves meet, cancel, and you hear silence.

Amplitudes behave like waves. A quantum algorithm is a carefully designed sequence of steps where:

• the paths leading to wrong answers end up with amplitudes that cancel each other out, and
• the paths leading to the right answer end up with amplitudes that reinforce each other.

When you finally measure, the right answer comes out with high probability, because the wrong ones have been mostly cancelled away.

That's why quantum computers are not faster at everything. Designing a sequence of steps that cancels wrong answers is very hard, and it's only possible for problems with the right mathematical structure. Where such a sequence exists, the speed-up can be enormous. Where it doesn't, a quantum computer offers no advantage at all.

Entanglement: Two Coins That Always Agree

Entanglement is what happens when two or more qubits share a single quantum state, so that you can no longer describe each one on its own.

Picture two coins spinning in the air, prepared together in a special way. Each coin, on its own, lands randomly: heads half the time, tails half the time. But every single time, the two coins land the same way. Both heads, or both tails. Never one of each.

That is exactly the state you'll build in the circuit below, called a Bell state. Measure the pair 1,000 times and you get roughly half 00 and half 11, and never 01 or 10.

Two clarifications keep this accurate:

• It's not just "they were decided in advance." You might think the coins secretly agreed on heads or tails before they were separated, like a pair of gloves split into two boxes. Experiments (the ones behind the 2022 Nobel Prize in Physics) have shown that no hidden plan of that kind can explain the results. The correlation is genuinely quantum.
• It can't be used to send messages faster than light. Each person, looking only at their own coin, sees a random result. The agreement only shows up when the two sets of results are compared, and that comparison has to travel the normal way.

For computing, entanglement matters because it lets a group of qubits behave as one system whose state grows exponentially with the number of qubits. Without entanglement, a quantum computer could be simulated easily on an ordinary computer, and there would be no point building one.

Quantum Gates: The Instructions

A classical computer changes bits with logic gates. A quantum computer changes qubits with quantum gates. A gate takes a qubit's state (its amplitudes) and transforms it into a new one.

You only need four gates to follow almost any beginner material:

Two things make quantum gates different from classical ones:

• They are reversible. Every quantum gate can be undone. An AND gate can't: if the output is 0, you can't tell which inputs produced it. Quantum gates never throw information away.
• They act on amplitudes, not on values. The Z gate shows this best. Measure straight after it and you'd never know it was there. But it flips a sign, and signs decide what cancels and what reinforces later. That's interference being programmed.

Quantum Circuits: Putting Gates in Order

A quantum circuit is a quantum program: a set of qubits, a sequence of gates applied to them, and measurements at the end. Circuits are usually drawn as horizontal lines (one per qubit) with gates placed on them, read from left to right like a musical score.

Here is the most famous beginner circuit, the one that creates the entangled pair of "coins that always agree":

Step by step:

1. Start. Both qubits begin in |0⟩. Every quantum circuit starts from a known state.
2. Hadamard on qubit 0. Qubit 0 is now in an equal superposition: a spinning coin.
3. CNOT from qubit 0 to qubit 1. "If qubit 0 is 1, flip qubit 1." Because qubit 0 is in superposition, so is the condition. The result is a single shared state of both qubits: half "both 0", half "both 1". They are now entangled.
4. Measure both. The superposition ends.
5. Result. Across many shots you see 00 about half the time and 11 about half the time. You never see 01 or 10.

In code, using Qiskit (IBM's open-source Python library and the most widely used quantum programming toolkit), the same circuit is five lines:

from qiskit import QuantumCircuit
 
qc = QuantumCircuit(2)   # two qubits, both start at 0
qc.h(0)                  # Hadamard: put qubit 0 into superposition
qc.cx(0, 1)              # CNOT: entangle qubit 0 with qubit 1
qc.measure_all()         # read both qubits
 
print(qc.draw())         # show the circuit as a diagram

The programming post later in this series will install Qiskit, run this on a simulator and then on real quantum hardware, and explain the results line by line. For now, the important thing is that a quantum program is not mysterious: it's a list of gates in order, exactly like the diagram.

Try It Yourself, No Installation Needed

You don't need Python or a physics degree to see this happen. IBM offers a free, browser-based drag-and-drop tool called Quantum Composer as part of the IBM Quantum Platform.

Step 3 is the one worth pausing on. If a qubit were just a coin whose result we don't know yet, setting it spinning twice would still give a random answer. It doesn't. That single experiment is the clearest demonstration that a qubit is not "0 or 1, we just don't know which," and not quite "0 and 1 at the same time" either. It's a state with amplitudes that can cancel.

Why Quantum Computers Are Different (and What They Are Not)

Putting it all together:

And, just as important, what quantum computers are not:

• They are not faster versions of your laptop. Email, web browsing, spreadsheets, games and most business software will never run better on a quantum computer.
• They will not replace classical computers. They work alongside them, the way a GPU accelerates AI workloads for a normal CPU. A classical computer prepares the problem, sends a circuit to the quantum processor, and processes the results.
• They are not magic for AI. There is serious research into quantum machine learning, but no evidence yet that quantum computers will speed up the training of today's large AI models.

Where they are expected to matter: simulating molecules and materials (chemistry, drug discovery, batteries), certain optimisation problems, and factoring large numbers. That last one is why security teams care: a large enough quantum computer running Shor's algorithm could break RSA and elliptic-curve encryption, the public-key cryptography behind HTTPS, VPNs and the certificates discussed in the Intune PKI deep dive. That's a whole post of its own later in the series.

The Hard Part: Why We Don't All Have One Yet

If the principles are this clear, why is quantum computing still "coming soon"? Because qubits are extraordinarily fragile.

A superposition survives only while the qubit is perfectly isolated from its surroundings. A stray vibration, a little heat or a faint electromagnetic signal acts like an accidental measurement and destroys it. This is called decoherence, and it's why superconducting quantum computers sit inside refrigerators colder than outer space.

The result is noise: every gate has a small chance of going wrong, and errors pile up as circuits get longer. Today's machines, with tens to a few thousand physical qubits, are often called NISQ devices (Noisy Intermediate-Scale Quantum).

The solution is quantum error correction: spreading the information of one reliable logical qubit across many physical qubits, and constantly checking for and fixing errors without measuring (and destroying) the actual data. Useful, large-scale algorithms like Shor's need thousands of logical qubits, which means very large numbers of physical ones.

This is also exactly why the field is accelerating now. In late 2024, Google's Willow chip showed that adding more physical qubits to an error-corrected logical qubit made it more reliable, not less, a long-awaited milestone. Microsoft, IBM, Quantinuum and others have since published roadmaps aimed at fault-tolerant machines around the end of this decade. Error correction is moving from theory to engineering, and that is what turns quantum computing from a research topic into a technology roadmap. The "Future Quantum Systems" posts in this series will cover it properly.

Why Quantum Is Picking Up Speed After AI

AI and quantum computing are often mentioned in the same breath, but they are moving for different reasons, and the reasons reinforce each other:

• Error correction is finally working in practice. As above, this is the technical milestone the field waited decades for.
• Cloud access removed the hardware barrier. IBM Quantum, Azure Quantum and Amazon Braket let any developer run circuits on real machines, the same way cloud GPUs opened up AI.
• AI made the world hungry for compute. AI showed how much value specialised hardware can unlock, and pushed governments and investors to look for the next leap in computing power.
• AI is helping build quantum computers. Machine learning is already used to decode error-correction signals, calibrate qubits and design better circuits.
• Security has a deadline. In 2024 the US National Institute of Standards and Technology (NIST) published its first post-quantum cryptography standards, and organisations are being asked to plan their migration now, because encrypted data stolen today could be decrypted by a quantum computer later ("harvest now, decrypt later").

Stage 06 explores this convergence in depth in Why Is Quantum Computing Accelerating Now?, including the feedback loop between AI and quantum computing. None of this means a quantum computer will be on your desk soon. It does mean that understanding the basics, the way IT professionals learned cloud a decade ago and AI over the last few years, is quickly becoming part of the job.

Quick Recap: The Seven Ideas

If you remember only one thing, make it this: a quantum computer doesn't check every answer at once. It sets up amplitudes so that wrong answers cancel and the right answer survives measurement. Everything else in this series builds on that idea.

What's Next on the Learning Path

This post is stage 01. Its companion, Superposition, Entanglement and Measurement Explained Without Heavy Mathematics, turns the pictures in this post into precise concepts, and is the best next read. The rest of the path moves from what to how, and then to why it matters:

If you're coming from the AI side of this site, What Is Artificial Intelligence? is the equivalent starting point there, and the two series will meet again when we look at quantum and AI together.