How to Run Your First Quantum Circuit on a Free Cloud Simulator: Step-by-Step

You do not need a cryostat, a dilution refrigerator, or a research budget to run a quantum circuit. The gate model — qubits, superposition, entanglement, measurement — behaves the same way in a simulator as it does on real hardware, minus the noise and the waiting list. Every major quantum cloud platform offers a free tier that executes your circuit on a classical machine emulating a quantum one, and the whole exercise takes about twenty minutes from signup to first histogram.

Here is the full path: create an account, open a circuit composer, drag two gates onto the canvas, run the thing, and learn to read what comes back.

What You Need Before You Touch a Gate

Nothing exotic. A browser, an email address, and a rough idea of three concepts:

• A qubit is a two-level system whose measurement returns 0 or 1. Unlike a classical bit, it can be in a combination of both until you measure it.
• A gate is an operation applied to one or more qubits. The Pauli-X gate flips a qubit; the Hadamard puts it into an even mix of 0 and 1; the CNOT entangles two qubits.
• Measurement is the step that turns quantum information into ordinary bits you can count. Without it, your circuit produces nothing you can plot.

If those three sentences feel shaky, that is fine. The composer will make them concrete faster than any explanation will.

Step 1: Pick a Platform and Sign Up

For a first circuit, use a drag-and-drop composer rather than a code framework. IBM Quantum Platform's Composer is the most established free option: you register, confirm your email, and land in a workspace with a visual editor, a simulator, and a small monthly allowance for real hardware once you want it. Qiskit, the Python library behind that platform, runs locally for free and never queues, but it asks you to install a package first.

If you would rather skip registration entirely, Quirk is a browser-based simulator that opens instantly and draws probabilities live as you place gates. It has no account, no queue, and no hardware access — which makes it an excellent scratchpad and a poor place to learn the workflow of a real platform.

Pick one and commit for the session. Switching tools halfway through is how beginners end up with two half-finished accounts.

Step 2: Read the Canvas Before You Build

A circuit canvas looks like sheet music, and it is worth thirty seconds to understand the notation. Each horizontal line is one qubit. Time runs left to right. Columns are moments in time — gates stacked in the same column execute together, provided they touch different qubits. The flat line at the bottom is the classical register, where measurement results land.

On the left sits a palette of gates. In IBM's composer you will find single-qubit gates near the top and the CNOT below them, usually drawn as a filled dot for the control and a circled plus for the target. Drag a gate onto a line and it snaps into place; click it and a small menu appears for deleting or relocating it.

Step 3: Build a Bell State, Gate by Gate

The circuit that convinces people this is real is the Bell state. It takes two gates and produces a result no classical pair of bits can reproduce.

Place the Hadamard

Drag an H gate onto qubit 0, the top line, in the first column. This puts the qubit into an equal superposition of 0 and 1. On its own, it would measure as 0 roughly half the time and 1 the other half.

Add the CNOT

Drag a CNOT so that qubit 0 is the control and qubit 1 is the target. The target flips only when the control is 1 — and because the control is in superposition, the two qubits become correlated rather than independent.

Check the Wiring

Confirm the control dot is on qubit 0 and the target is on qubit 1. Getting these backwards is the single most common beginner error, and the results will look perfectly plausible while meaning something else.

If your composer does not add measurements automatically, drag measurement operations onto both qubits at the far right. In Qiskit you will need to call the measure method explicitly before running.

Step 4: Choose a Backend and Set Your Shots

Run your circuit on a simulator, not a real device, for this first attempt. Simulators come in two flavours: statevector simulators, which compute exact probabilities with no noise, and shot-based simulators, which mimic the statistical behaviour of repeated real runs. Choose a shot-based simulator if you want your histogram to resemble what hardware would give you.

Shots are the number of times the circuit is executed and measured. Defaults are usually around a thousand. More shots produce a smoother histogram; fewer produce a blockier one with visible sampling noise. Start with the default and change it later to see the difference — it is a useful lesson in itself.

Step 5: Read the Histogram

When the job finishes, you get a bar chart. The horizontal axis lists outcome bitstrings — 00, 01, 10, 11 — and the vertical axis counts how often each appeared across your shots.

For the Bell state, expect two tall bars: 00 and 11, each near half the shots. The 01 and 10 bars should sit close to zero. What you are seeing is entanglement: whenever the first qubit reads 0, the second reads 0 too, and when the first reads 1, so does the second. There is no single run in which the two disagree.

Two details trip people up here. First, a single shot never shows a superposition. You get one bitstring per shot; the superposition only becomes visible across many shots. Second, bit ordering varies between tools. In Qiskit's default output, qubit 0 is the rightmost character of the string, so a result labelled 10 means qubit 0 measured 1 and qubit 1 measured 0. Check your platform's convention before you draw conclusions.

When the Histogram Looks Wrong

A flat histogram across all four outcomes usually means the two qubits are behaving independently, which points to one of these:

• The CNOT is missing, misplaced, or has control and target reversed.
• Measurements were never added, so the platform measured nothing meaningful.
• You ran on real hardware, where gate errors smear the ideal 50/50 split into neighbouring outcomes.
• Your shot count is so low that sampling noise dominates the picture.
• An extra gate crept onto the canvas. Click along the circuit and check every column.

Three Circuits to Try Next

1. Interference. Apply H, then Z, then H to one qubit, and measure. The answer comes back 1 every time — the two paths cancel rather than adding. This is amplitude interference, the mechanism quantum algorithms exploit.
2. GHZ state. Add a third qubit and chain two CNOTs from qubit 0. Your histogram collapses to 000 and 111.
3. Shot-count experiment. Run the simple H circuit at 100 shots, then 1000, then 10000. Watch the bars even out toward 50/50.

Make It a Ten-Minute Weekly Habit

The fastest route from curious to competent is repetition on small circuits. Keep a file or notebook page where you record the circuit, the backend, the shot count, and the histogram you got. After a few weeks you will start predicting results before you run them, which is the moment the gate model stops being abstract.

When your simulator results feel predictable, request access to a real device on the same platform and run the same Bell circuit. The 01 and 10 bars will not be empty anymore — noise, readout error, and decoherence will push counts into them. That gap between the clean simulator and the messy machine is where most of quantum computing's engineering work actually lives, and seeing it for yourself is worth more than reading about it.

Photo: Daniil Komov / Pexels