Quantum Hardware Compared: Superconducting vs Trapped-Ion vs Photonic vs Neutral-Atom

“What hardware should I run on?” is a more consequential question than it sounds. The four leading qubit modalities differ by orders of magnitude on every axis — gate speed, coherence time, connectivity, qubit count, queue time, cost per shot. Picking the wrong one for your problem is the difference between a 10-minute experiment and a 10-hour one, between a clean result and a noise-drenched mess.

This tutorial is an opinionated comparison. No vendor-neutral fence-sitting — for each modality I say what it’s best at, where it breaks down, and when an indie dev should actually reach for it.

The four modalities in one paragraph each

Superconducting (IBM, Google, Rigetti, IQM)

Qubits are macroscopic LC resonators on a chip, cooled to ~10 mK so that the lowest two energy levels become a qubit. Single-qubit gates: microwave pulses driving transitions, ~20-50 ns. Two-qubit gates via resonant coupling or cross-resonance, ~50-400 ns. Coherence: $T_1 \sim 100$-$500\,\mu s$. Scaling: well underway — IBM Condor (1,121 qubits, 2023), Nighthawk (~1,500 qubits, 2025), Kookaburra (~4,000 qubits, 2026) via chip coupling. Dominant modality for fault-tolerance timelines.

Trapped-ion (IonQ, Quantinuum)

Single atomic ions (typically ⁴⁰Ca⁺ or ¹⁷¹Yb⁺) held in electromagnetic traps, laser-driven for gate operations. Single-qubit gates: ~1-10 µs (slower than superconducting). Two-qubit gates: ~50-200 µs via collective motional modes. Coherence: $T_1 \sim 60$ seconds (five orders of magnitude better than superconducting!). All-to-all connectivity within a trap — no SWAP cost. Scaling: much slower, because you need to keep ions stable while adding them. Quantinuum H2: 56 qubits. Latest IonQ Tempo: 64 qubits. Dominant modality for algorithm demonstrations that need lots of gates and low error.

Photonic (Xanadu, PsiQuantum)

Qubits are modes of light — a single photon encodes a “dual-rail” qubit in a superposition of two optical modes (e.g., two waveguides). Gates are beam-splitters, phase shifters, and non-linear elements. Runs at room temperature (! — no dilution fridge needed). Measurement via photon detectors. Coherence: effectively unlimited while the photon exists, but photon loss is the dominant error channel. Scaling: PsiQuantum targets 1 million physical qubits by 2027-2028 (silicon photonics is mass-manufacturable). Xanadu Borealis: 216-mode photonic computer, went public via SPAC March 2026. Only modality with a credible path to mega-scale directly.

Neutral-atom (QuEra, Pasqal, Atom Computing)

Neutral atoms (typically Rb or Cs) trapped in optical tweezers — focused laser beams holding atoms in place. Gates via Rydberg-state excitation: elevate atoms to a high-energy state where they strongly interact, perform entangling operations, then de-excite. Coherence: seconds. Programmable connectivity: you can physically rearrange atoms between gate rounds, enabling arbitrary interaction topologies. Scaling: fastest growth in the field — QuEra has 448 physical atoms / 96 logical qubits (Jan 2026); Atom Computing: 24 entangled logical qubits; Pasqal: ~1000 physical, targeting 10,000 by end-2026. The modality most likely to deliver the first million-qubit system.

The 2026 scorecard

The three axes that matter

Gate speed vs gate error

Superconducting: fast, noisier. Trapped-ion: slow, cleaner. On a clock per-dollar basis they trade. For a 1000-shot experiment on a shallow circuit, IBM is 30× cheaper in wall-clock. For the same experiment at the same fidelity, you’d need error mitigation or distance-5 error correction on IBM, essentially equalizing cost.

Rule of thumb: depth < 50 → IBM/Google; depth > 100 → Quantinuum. The crossover is where gate error times depth exceeds ~0.5.

Connectivity

• All-to-all (trapped-ion, neutral-atom with rearrangement): any 2-qubit gate without SWAP chains. A 30-qubit QFT is ~200 CNOTs; superconducting hardware needs ~500 because of SWAPs.
• Local (superconducting): you pay SWAP chains for every long-range gate. On a 20-qubit heavy-hex lattice, the average pairwise qubit distance is 3-4 hops, so a non-local 2-qubit gate costs 3-4× overhead.
• Programmable (neutral-atom): between syndrome rounds you can physically move atoms to set up whatever interaction graph you want. Unique and underused in current software.

Scalability path

• Superconducting: ~1000-4000 qubits on one chip, chip-to-chip interconnects at ~10 cm. Path to ~1M via module tiling. 10-15 years out.
• Trapped-ion: ~100 qubits per trap. Trap-to-trap ion transport is slow (~ms). Scaling to 1000+ is an open engineering problem. 15+ years out.
• Photonic: manufacturing-style scaling (silicon photonics fab lines). PsiQuantum claims 2027-2028 for 1M-qubit system. Most optimistic timeline in the field.
• Neutral-atom: optical tweezer arrays scale to tens of thousands of atoms with minimal added complexity — QuEra already demonstrated 6,000-atom arrays. Most likely to deliver 10K qubits first.

How to pick a backend

If you’re an indie dev experimenting, this decision tree works:

1. Are you learning? → IBM Quantum free tier. 10 minutes/month of compute, every tutorial works out of the box, best docs.
2. Are you debugging a short circuit where fidelity matters? → Quantinuum via cloud. Pay per shot; expect 1000-10,000 shots total for typical debugging.
3. Are you benchmarking an algorithm? → Always simulator first (qiskit-aer with realistic noise model). Only hit real hardware once the simulator result matches expectation.
4. Do you want “something novel for a blog post?” → Neutral-atom hardware (QuEra via AWS, Pasqal via Azure). Under-covered in tutorials, interesting connectivity, different errors.
5. Are you writing a paper with a claimed quantum-advantage result? → Hire a hardware physicist. No cloud API is sufficient for a peer-reviewed-grade benchmark.

The Cloud Aggregators

For an indie dev it usually doesn’t make sense to integrate with 4 different cloud APIs. Use an aggregator:

• Amazon Braket. IonQ, Rigetti, QuEra, Oxford Quantum Circuits. Unified API, pay-per-shot.
• Azure Quantum. IonQ, Quantinuum, Rigetti. Unified API. Strong for Microsoft-shop enterprises.
• qBraid. 34+ devices, 18+ SDKs. Cheapest for learning; strong Python SDK.
• Classiq. Higher-level circuit description language; targets the above clouds.

For tutorials and blog posts, qBraid has the best pricing and coverage. For production/commercial use, Braket because you can bill via existing AWS accounts.

Emerging / honorable mentions

Not the big four, but worth watching:

• Spin qubits (Intel, HRL, Silicon Quantum Computing). Semiconductor-compatible, small footprint, low $T_2$. Scaling story is manufacturing-friendly (silicon CMOS) but gate fidelity lags.
• Topological qubits (Microsoft Majorana). 2023-2024 showed possible Majorana zero modes; 2025 Microsoft announced “topological qubit” with ~1 qubit scale. Fabrication extremely challenging. Multi-decade research bet.
• NV-center qubits (Quantum Brilliance). Diamond nitrogen-vacancy centers; room temperature operation; optical readout. Niche for quantum sensing; limited scalability.

Real-hardware workflow on each modality

A concrete walkthrough of running the same Bell-state circuit on each:

# IBM Quantum (superconducting)
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler
service = QiskitRuntimeService()
backend = service.backend("ibm_brisbane")       # Eagle r3, 127 qubits
# ... compose circuit, transpile, sampler.run(qc, shots=4096)

# Amazon Braket — IonQ (trapped-ion)
from braket.aws import AwsDevice
device = AwsDevice("arn:aws:braket:us-east-1::device/qpu/ionq/Harmony")
# ... compose circuit, device.run(qc, shots=100)   # ion traps are shot-slow

# Amazon Braket — QuEra (neutral-atom)
device = AwsDevice("arn:aws:braket:us-east-1::device/qpu/quera/Aquila")
# QuEra supports "analog Hamiltonian simulation" mode; gate-model support is newer

# Xanadu Cloud (photonic)
import strawberryfields as sf
eng = sf.RemoteEngine("X8")                    # 8-mode photonic device
# ... PhotonicCircuit, engine.run(prog, shots=1000)

Each vendor has its own circuit-description paradigm; OpenQASM 3 support is uneven. Use a framework like Braket or qBraid if you want to write circuits once and run everywhere.

Cost-per-useful-result comparisons

Rough estimates for running a specific benchmark — factoring $N = 15$ with Shor’s algorithm (11-qubit circuit, ~200 gates):

For a learning/blog benchmark, simulator and IBM free tier handle 99% of what you need. Quantinuum’s shot time and cost only make sense when you’re writing a paper and need the best fidelity you can buy.

Exercises

1. SWAP budget comparison

A 20-qubit circuit has 100 two-qubit gates between random qubit pairs. How many SWAPs does it need on (a) IonQ all-to-all, (b) IBM heavy-hex with average distance 3?

2. Pick a backend

You want to run a 15-qubit QAOA instance with a circuit depth of ~60. Where should you run? Justify the pick.

3. Photonic-specific reasoning

Why is coherence “effectively unlimited” on photonic platforms but photon loss is the dominant error? How does this change the error-correction strategy?

4. Future-proofing your code

Write a small Python wrapper that takes an OpenQASM 3 string and dispatches to IBM, IonQ via Braket, or the Aer simulator, depending on a config flag. What’s the minimum circuit representation that works across all three?

def run(qasm_src: str, backend_name: str, shots: int):
    if backend_name == "aer":
        from qiskit import qasm2, transpile
        from qiskit_aer import AerSimulator
        qc = qasm2.loads(qasm_src)
        return AerSimulator().run(transpile(qc), shots=shots).result().get_counts()
    # ... other branches

What you should take away

• Superconducting wins on speed and scaling roadmap; loses on coherence.
• Trapped-ion wins on gate fidelity and coherence; loses on speed and scalability.
• Photonic wins on room-temperature operation and mass-manufacturing path; loses on coherent operations (gates are harder).
• Neutral-atom wins on programmable connectivity and scaling growth rate; loses on gate speed and error rates.
• Pick based on circuit depth and tolerance for error — shallow circuits run anywhere; deep circuits need trapped-ion or error correction.
• Simulators + IBM free tier cover 99% of learning work. Paid hardware is for specific-result publication, not experimentation.

Next: Post-Quantum Cryptography: The Threat Model. The part of this track where quantum knowledge converts to actual indie revenue.