IBM Quantum Learning

You have learned what a qubit is. You have learned what a Hadamard gate does. You have learned how a CNOT entangles two qubits into a Bell state. You have done all of this on paper, with pencil, in this wiki track. And you are starting to wonder: what would it feel like to actually run a quantum circuit on a real quantum computer, not simulate it in your head?

Ten years ago, the answer was "good luck" — real quantum hardware lived inside university physics labs, cost tens of millions of rupees, and was accessible only to graduate students with the right advisors. Today, the answer is: open a browser, sign up for a free IBM account, write twelve lines of Qiskit, and press Run. Your circuit is queued onto a superconducting quantum processor sitting in a dilution refrigerator at 15 millikelvin somewhere in Yorktown Heights, New York. Your results arrive in your browser a few minutes later. You have run your first real quantum computation.

The free platform that makes this possible is IBM Quantum Learning, at learning.quantum.ibm.com. It is the single best on-ramp between a textbook understanding of quantum computing and real hands-on experience. This chapter is a tour: what is on the platform, which course to take in which order, how the real-hardware access works, and two worked examples — a Bell state on an IBM Heron chip, and a molecular-hydrogen VQE calculation — that you can follow step by step once you have an account.

What IBM Quantum Learning is, and what it is not

Before the tour, set expectations. IBM Quantum Learning is three things fused together:

1. A video-lecture platform. Long-form video courses taught by researchers, notably John Watrous (University of Waterloo, now IBM), one of the most-cited writers on the theory of quantum information. His lectures are rigorous and polished.

2. An interactive coding environment. Jupyter-notebook-style exercises that run Qiskit — IBM's Python quantum SDK — either on your browser's simulator or on real hardware. Every concept the videos teach has a corresponding coding exercise.

3. A portal to real IBM quantum hardware. Each registered user gets access to IBM's cloud quantum backends: currently the 133-qubit Heron chips and various simulators. Ten minutes of compute time per month on real hardware are free.

It is not a substitute for this wiki track. Watrous's lectures are mathematical (definitions, theorems, proofs); our track is narrative (stories, analogies, worked examples). It is not a research platform — serious research on IBM hardware requires a paid Premium or Pay-as-you-go plan with much more compute time. And it is not cross-vendor — if you want to run on Google Willow or Quantinuum H2, you need to use Google's Cirq or Quantinuum's own SDK instead (see our SDKs chapter).

What it is: a well-curated, free, high-quality learning path that gets a motivated beginner from "I know what a qubit is" to "I have run a VQE on real hardware" in roughly 40–60 hours of structured work.

The five-course learning path

The core of the platform is a structured path of five courses, totaling around 40 hours of video plus exercises. Three are taught by John Watrous; two are IBM-internal productions. Take them in this order on your first pass.

Course 1 — Basics of Quantum Information

The foundation. Watrous begins with classical information — bits, strings, probability distributions — and builds quantum concepts as direct generalisations. By the end of the course you have seen qubits, the Pauli matrices, the Hadamard, the CNOT, measurement, and enough linear algebra to follow the rest of the series.

Duration: around 8 hours of video plus 6–10 hours of coding exercises.

This course overlaps almost completely with Parts 1–5 of our wiki track. If you have worked through those parts, you can skim Course 1 at 2× playback speed and spend your time on the coding exercises, which is where Watrous's treatment adds value our text track cannot.

Course 2 — Fundamentals of Quantum Algorithms

The algorithm core: Deutsch–Jozsa, Simon, Grover, Shor, Quantum Fourier Transform, phase estimation. Watrous's derivations are clean and his notation is careful — he will write out the full superposition before each Hadamard application and then show you what the Hadamards produce. If you are a visual learner and you have struggled with Shor's algorithm in text, these videos are the clearest derivation I know.

Duration: around 10 hours of video plus 8–12 hours of exercises.

This maps to our Parts 8–11. The overlap is heavier on the mathematical treatment; our track gives you more of the "why this matters" narrative.

Course 3 — General Formulation of Quantum Information

The rigorous layer. Density matrices, quantum channels (CPTP maps), partial trace, purification, fidelity, trace distance, entanglement measures. This is where Watrous's own research background is most visible — he is one of the best writers alive on the abstract theory of quantum channels, and this course is the condensed version of his textbook The Theory of Quantum Information.

Duration: around 8 hours of video, heavy on math.

This maps to our Parts 12–14, but Watrous goes further into pure information theory than we do. If you find you love this course, you love quantum information theory and should read Watrous's book and John Preskill's Chapter 10. If you find it dry, skip to Course 4 — this material is less crucial for most applied paths.

Course 4 — Quantum Error Correction

The final Watrous course. Stabilizer codes, the 3-qubit bit-flip code, the Shor code, the Steane code, the surface code. Error correction is historically the hardest part of the curriculum and Watrous handles it in roughly 6 hours with a steady, building pace.

Duration: around 6–8 hours of video plus 4–6 hours of exercises.

This maps to our Parts 15–18 on error correction and fault tolerance. Our track goes further on the engineering side (surface-code logical qubits, threshold theorems in practice); Watrous is sharper on the mathematical structure.

Course 5 — Practical Introduction to Quantum Computing (IBM production)

The applied finale. This is the course where you learn to actually program Qiskit 2.0: writing circuits, using the Estimator and Sampler primitives, transpiling to specific hardware, reading calibration data, running on real QPUs. Less lecture, more lab.

Duration: around 8–12 hours of hands-on work.

This does not map to a single part of our track — it is cross-cutting. Do this course last, after you have the theoretical foundation from Courses 1–4.

The free cloud QPU allowance — what it actually gets you

The number that makes IBM Quantum Learning different from any other free course is 10 minutes of real-quantum-hardware compute time per user per month. Free. No paywall, no trial, no credit card.

What 10 minutes actually means. A single quantum circuit on Heron executes in tens of microseconds (the gates run on nanosecond timescales; the slowest step is the measurement, around 2 microseconds per qubit). But IBM's allowance is measured in wall-clock time on the QPU, which includes your circuit's shots (repeated runs for statistics), compilation time (transpiling your circuit to the chip's native gates), and overhead (loading the circuit into the hardware, reading out results).

A rough accounting. A small circuit (2–5 qubits) with 1,000 shots typically uses around 1–3 seconds of wall-clock QPU time including overhead. 10 minutes is 600 seconds, so you can run roughly 200–600 small circuits per month on real hardware. Enough for serious learning, not enough for a large research project.

Why this is the right pedagogical amount: one circuit a day, every day, for a month, gives you 30 real-hardware runs. After 30 runs you have seen every common failure mode — decoherence, readout error, crosstalk, bad calibration days — and you have internalised what "real hardware is noisy" actually feels like. That is the lesson you cannot get from a simulator.

The queue. Real hardware at IBM is shared across tens of thousands of users. When you submit a job, it joins a queue. Free-tier users wait minutes to hours, sometimes longer during peak times. Paid-tier users (Pay-as-you-go at roughly $1.60 per second of QPU time, Premium for enterprise) have priority queues. On the free tier, plan your experiments during less-busy times — Indian evenings are often surprisingly fast because the US is still morning.

The backends. As of 2026, free-tier access is typically to the ibm_brisbane, ibm_kyiv, and ibm_sherbrooke Heron chips (133 qubits each) and smaller demonstration chips. Which specific chips are available changes as IBM retires older machines and rolls out new ones — check service.backends() in Qiskit to see what's live today.

Example: run a Bell state on IBM Heron

Let's do the canonical "hello, quantum" — a Bell state — on real IBM hardware. A Bell state is a two-qubit state of maximal entanglement: apply a Hadamard to the first qubit, then a CNOT with the first as control and the second as target.

Why a Bell state is the first thing you run on real hardware: it is the smallest circuit that tests all three essential operations — superposition (Hadamard), entanglement (CNOT), and correlated measurement. On a perfect quantum computer, measuring both qubits gives 00 half the time and 11 half the time, with exactly zero 01 or 10. On a real noisy chip, you will see 01 and 10 a few percent of the time, which is how you measure the gate-error rate.

pip install qiskit qiskit-ibm-runtime

from qiskit_ibm_runtime import QiskitRuntimeService
QiskitRuntimeService.save_account(channel="ibm_quantum", token="YOUR_TOKEN")

from qiskit import QuantumCircuit
qc = QuantumCircuit(2, 2)
qc.h(0)           # Hadamard on qubit 0
qc.cx(0, 1)       # CNOT with control 0, target 1
qc.measure([0,1], [0,1])  # measure both qubits

from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit import transpile
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)
print(f"Running on {backend.name}")
qc_t = transpile(qc, backend, optimization_level=1)
sampler = Sampler(backend)
job = sampler.run([qc_t], shots=1000)
result = job.result()
counts = result[0].data.c.get_counts()
print(counts)

{'00': 487, '11': 486, '01': 14, '10': 13}

The specialty pathways

Beyond the five-course main path, the platform has specialty pathways for specific application areas. Each is 10–20 hours, assumes you have finished Courses 1–2, and focuses on one topic.

Variational Quantum Eigensolver (VQE) for chemistry

The most practical NISQ-era algorithm. You prepare a parameterised quantum state (an ansatz), measure the energy of some molecular Hamiltonian, and classically optimise the ansatz parameters to minimise that energy. The minimum is the ground-state energy of the molecule — a core chemistry quantity you cannot easily get from classical methods for strongly correlated systems.

The IBM VQE pathway walks through hydrogen (H₂), then lithium hydride (LiH), with the option to extend to larger molecules.

Quantum Machine Learning

A pathway using Qiskit Machine Learning and (increasingly) PennyLane. Variational quantum classifiers, quantum kernel methods, data re-uploading circuits. The pathway is honest about the fact that quantum ML has not yet demonstrated a clean practical advantage — see our chapter on dequantization — but it is a good place to learn the programming patterns.

Qiskit Runtime primitives

A developer-focused pathway on Estimator and Sampler, the two high-level primitives that abstract away circuit execution on IBM hardware. If you want to write production-style Qiskit code rather than tutorial snippets, this is the pathway to take.

Error mitigation

How to extract useful information from noisy quantum computers before fault-tolerance arrives. Zero-noise extrapolation, probabilistic error cancellation, dynamical decoupling, readout-error mitigation. A practical pathway that will be relevant to all NISQ-era work through the late 2020s.

Example: VQE on hydrogen (H₂) on a simulator

The second worked example: compute the ground-state energy of the hydrogen molecule using VQE. We will run on the simulator rather than real hardware for this one — VQE typically needs hundreds of circuit evaluations, which would exhaust a month's free allowance in one run.

from qiskit.circuit import QuantumCircuit, Parameter
theta = Parameter('θ')
ansatz = QuantumCircuit(4)
ansatz.x(0); ansatz.x(1)          # Hartree-Fock reference
ansatz.ry(theta, 2)                # single parameter
ansatz.cx(2, 3); ansatz.cx(1, 2); ansatz.cx(0, 1)

from qiskit_ibm_runtime import EstimatorV2 as Estimator
from qiskit.quantum_info import SparsePauliOp

H = SparsePauliOp.from_list([
    ("IIII", -1.0523732), ("IIIZ", 0.3979374), ("IIZI", -0.3979374),
    ("IIZZ", -0.0112801), ("IXIX", 0.1809312), ("ZXZX", 0.1809312),
    ("IIXI", -0.1809312), ("IZII", 0.3979374)  # schematic; full list has ~15 terms
])

def energy(theta_val):
    bound = ansatz.assign_parameters({theta: theta_val})
    estimator = Estimator(backend_simulator)
    pub = (bound, H)
    job = estimator.run([pub])
    return job.result()[0].data.evs.item()

from scipy.optimize import minimize
result = minimize(energy, x0=[0.0], method='COBYLA')
ground_energy = result.fun
optimal_theta = result.x[0]
print(f"VQE ground-state energy: {ground_energy:.6f} Hartree")
print(f"Exact (FCI): -1.137283 Hartree")

Complementary resources

IBM Quantum Learning is excellent, but it is not the only free quantum-education platform. Pair it with:

• Qiskit Textbook (qiskit.org/textbook) — the older, more introductory companion to the video courses. Good if you want a text-first rather than video-first experience.
• PennyLane codercamp and tutorials (pennylane.ai/qml) — Xanadu's variational-quantum-ML-focused platform. Complementary to IBM; runs on simulator by default, with access to multiple hardware backends including Xanadu's photonic processors.
• Microsoft Azure Quantum Learn modules (learn.microsoft.com/quantum) — Q# and Quantum Katas. Different language ecosystem, useful for cross-pollination of ideas.
• Nielsen & Chuang textbook — see our books chapter for the mapping. IBM's video lectures are not a replacement for Nielsen & Chuang; they are a complementary treatment.
• John Preskill's Caltech lecture notes (theory.caltech.edu/~preskill/ph229) — free, graduate-level. Best for readers who want the rigorous version after finishing Courses 1–3.
• Indian academic resources. IIT Madras has published open lecture notes on Qiskit; IISc Bangalore runs periodic Qiskit workshops; the National Quantum Mission's training modules are increasingly online. Follow the Quantum Ecosystem India newsletter (QEI) for updates.

Common confusions about IBM Quantum Learning

• "The free tier is crippled and you need to pay for anything real." False. The free tier gives you real hardware access, 10 minutes per month is genuinely enough for learning and for small research projects, and the simulator backends are unlimited and fast. You can run a full Grover's algorithm demo, a small VQE, a Deutsch–Jozsa test, or a Bell state experiment on real hardware without paying anything. Paid tiers exist for serious research (hundreds of hours of compute) but are not needed for learning.

• "I need to be at a university with an IBM Quantum Network membership." False. The free tier works for any individual with an email address. Network membership adds priority queue access and more compute time, but the free tier is independently sufficient for self-study. IIT Madras, IIT Kanpur, TIFR, and IISc are IBM Quantum Network members — if you are a student at one of those institutions, ask your faculty about getting a network-tier account.

• "Watrous's lectures are too mathematical." Partially true. Watrous is a mathematical computer scientist, and his pacing assumes you are comfortable with linear algebra at an upper-undergraduate level. If you find the lectures too dense, watch them at 0.75× speed, pause frequently, and supplement with our wiki track's narrative treatment. On a second pass, after you know the material, the same lectures feel much more accessible.

• "Qiskit 2.0 broke all the tutorials." Partially true. The migration from Qiskit 1.x to 2.0 in 2024 was real — the old IBMQ provider was replaced, QuantumCircuit grew a new transpiler API, and the primitive names changed (from Estimator and Sampler to EstimatorV2 and SamplerV2). Any tutorial dated before mid-2024 may need small fixes. The modern 2.0 API is cleaner and more stable; after about 20 minutes of adjustment the new style is easier.

• "Real-hardware results are too noisy to learn anything." False, and the opposite is the important lesson. Real-hardware noise is not an obstacle to learning — it is the lesson. Every quantum-computing professional in the world deals with noise daily. Running your Bell state on real hardware and seeing 2.7% error is how you understand what "fidelity" means in practice. The noise is the most valuable part of the experience a simulator cannot give you.

Going deeper

The primitive-based Qiskit 2.0 architecture

Qiskit 2.0's core abstraction is the primitive: a high-level operation you can run on any backend. There are two:

• Sampler — takes a circuit and returns the measurement outcome counts. "What do the measurements look like when I run this circuit N times?"
• Estimator — takes a circuit and an observable (a Hermitian operator), returns the expected value \langle\psi|O|\psi\rangle. "What is the average value of the observable on the state this circuit prepares?"

Almost every Qiskit program can be expressed as a sequence of Sampler and Estimator calls. This is deliberate: by standardising at this level, IBM can swap out the underlying hardware (Heron, future Starling, future Blue Jay) or simulation strategy (exact, approximate, tensor-network) without your code changing. You write Estimator.run(circuit, observable) and trust the backend to do the right thing.

This design also enables error-mitigation layering. When you ask the Estimator for an expected value on a real noisy chip, it can run internal post-processing — zero-noise extrapolation, probabilistic error cancellation, readout-error mitigation — transparently. Your code stays simple; the "quality" of the answer improves automatically as IBM's mitigation stack improves.

What the transpiler does

Your abstract circuit has arbitrary gates. The Heron chip only knows a handful of native gates: single-qubit rotations (rz, sx, x) and the ECR (echoed cross-resonance) gate for two-qubit operations. The transpiler's job is to turn your abstract circuit into an equivalent circuit in the native gate set, respecting the chip's connectivity graph (which pairs of qubits can actually interact) and calibration data (which qubits are currently the most accurate).

A Hadamard becomes a combination of rz and sx gates. A CNOT becomes an ECR gate plus single-qubit rotations. An arbitrary two-qubit unitary becomes a longer decomposition. The transpiler runs at optimization level 0–3; level 3 does the most aggressive gate cancellation and SWAP insertion but takes the longest. For learning, level 1 is fine.

The transpiled circuit is often 3–10× deeper than the abstract version. Circuit depth directly impacts fidelity (more gates = more chances for error), so understanding the transpiler is a large part of extracting real performance from real hardware.

Scheduling the 10 minutes per month

Ten minutes per month sounds like very little. It is enough because quantum circuits execute quickly. But to get the most out of it, plan your experiments in advance:

1. Prototype on the simulator first. Every experiment should run to completion on the qasm_simulator backend with a realistic noise model before you submit to real hardware. This catches all the bugs that are not about noise.

2. Run small shot counts for sanity checks. 100 shots on real hardware is often enough to confirm your circuit is running as expected. Then run 1,000–8,000 shots for the actual data you will use.

3. Batch multiple circuits. The Sampler can run multiple circuits in one job submission; you pay queue wait time once and get all results together. Useful for parameter sweeps.

4. Use off-peak hours. Indian evenings (late night US time) and Saturday mornings often have shorter queues.

5. Save your job IDs. Every IBM Quantum job has a permanent ID. Save it; you can fetch the result later without having to pay for the QPU time again.

With disciplined planning, 600 seconds a month supports roughly one serious small experiment per week plus daily tiny ones. Enough, with practice, to do a course project or a first research paper.

The Indian quantum-learner context

A growing number of Indian quantum-learning communities use IBM Quantum Learning as their primary hands-on resource. Qiskit Fall Fest India (annual, hosted by multiple IITs), the Qiskit Global Summer School (taught online each July, free, hundreds of Indian participants), and the Indian Women in Quantum Computing community all build around the platform. The QWorld India chapter hosts Qiskit tutorials in multiple Indian languages; Hindi, Tamil, Telugu, and Bengali materials are growing.

If you are a student in India starting out, joining one of these communities alongside the self-paced platform work makes the learning curve significantly gentler. Quantum computing is easier to learn with two or three peers working the same exercises than alone.

When to graduate beyond IBM Quantum Learning

After roughly 100–200 hours of platform work, you will have hit the ceiling of what guided learning can teach you. At that point, the graduation path is:

• Read arXiv. See the companion chapter for the weekly-habit plan. Now you are tracking the field's research output, not just its curriculum.
• Contribute to Qiskit. The Qiskit codebase is open source on GitHub. Fixing a bug or improving a tutorial is a legitimate research contribution and a great line on a CV.
• Write your own small paper. An original result — even a small one — belongs on arXiv. Your first arXiv submission with your own name on it is the real graduation.
• Apply for an internship. IBM Research India, TCS Research, QpiAI, BosonQ PSI, and the National Quantum Mission hubs at IITs all take interns. Platform experience is a genuine differentiator.

Where this leads next

• Reading an arXiv Paper — the companion chapter, for when you have outgrown guided tutorials.
• Nielsen Chuang Preskill Watrous — which textbook to pick for which question.
• Qiskit Cirq PennyLane CUDA-Q — the wider SDK ecosystem beyond Qiskit.
• The Landscape in 2026 — the ecosystem map, to see where IBM sits among its competitors.
• What is Quantum Computing? — chapter 1 of this track, useful to revisit before starting the platform.

References

1. IBM Quantum, IBM Quantum Learning — the platform itself, including Watrous's four-course series and specialty pathways.
2. John Watrous, The Theory of Quantum Information — the free-PDF textbook whose material Watrous's General Formulation course condenses.
3. IBM, Qiskit documentation — the live reference for Qiskit 2.0, Primitives, and the transpiler.
4. Peruzzo et al., A variational eigenvalue solver on a photonic quantum processor (2014) — arXiv:1304.3061. The original VQE paper underlying Example 2.
5. Nielsen and Chuang, Quantum Computation and Quantum Information — Cambridge University Press. The canonical textbook whose content IBM's video courses partly mirror.
6. John Preskill, Lecture Notes on Quantum Computation — the free graduate-level companion reading.