Qiskit Patterns and Primitives (IBM Learning)

The course that bridges quantum algorithm knowledge and practical IBM Quantum programming. Covers the modern Qiskit v1.0+ interface with Primitives and Qiskit Patterns, which replaced the older Backend.run() workflow.

This course is aimed at learners who already understand quantum algorithms and want to write production-quality quantum programs on IBM Quantum hardware. The move to Primitives and Qiskit Patterns was a significant API change in Qiskit v1.0, and this course is the definitive guide to the new workflow.

What you’ll learn

• Why Primitives were introduced: the limitations of the old Backend.run() approach and what the Sampler/Estimator abstraction layer provides
• The Sampler primitive: how to use it to estimate probability distributions over measurement outcomes, and when to use it over the Estimator
• The Estimator primitive: how to use it to estimate expectation values of observables, and why this is the right interface for variational algorithms like VQE and QAOA
• Qiskit Patterns: the four-step framework (map, optimise, execute, post-process) for structuring larger quantum programs in a modular and maintainable way
• Qiskit Runtime Sessions: how to open a session for repeated communication with IBM Quantum hardware while preserving calibration context between jobs
• Transpilation: how Qiskit maps your abstract circuit to a specific backend’s native gate set and coupling map, and how to control and inspect this process
• Error mitigation: built-in error mitigation techniques available through the Estimator primitive (TREX, ZNE, PEC) and when each is appropriate

Course structure

The course opens by explaining why the Primitives API exists and what problems it solves compared to the previous approach. This context makes the design choices comprehensible rather than arbitrary.

Sampler and Estimator are covered in dedicated sections with worked examples for each. The Qiskit Patterns framework is then introduced as an organisational principle for putting the pieces together into larger programs. Runtime Sessions and job management follow, covering the practical realities of submitting work to real hardware.

The transpilation and error mitigation sections equip learners to go beyond basic circuit submission and write programs that are both correct and practically executable on real hardware with manageable noise.

Who is this for?

• Quantum computing learners who know the algorithm theory and want to write working Qiskit code for IBM Quantum hardware
• Developers who learned Qiskit before v1.0 and need to update their knowledge of the current API
• Researchers who want to use IBM Quantum as a hardware platform and need to understand the execution model
• Software engineers building quantum applications on the IBM Quantum platform

Prerequisites

A solid understanding of quantum circuits is required: qubits, gates, measurement, and basic circuits should be fluent. Familiarity with the concepts behind quantum algorithms like VQE or Grover’s is helpful for understanding the motivation behind the Primitives design. Working Python skills and some prior Qiskit exposure are expected.

Hands-on practice

All exercises use the modern Qiskit v1.0+ API and IBM Quantum Runtime:

• Write circuits and execute them using the Sampler primitive, then read and interpret the resulting quasi-probability distribution
• Estimate expectation values of Pauli observables using the Estimator primitive for a specified Hamiltonian
• Structure a variational algorithm (VQE) using the Qiskit Patterns framework: map the problem, optimise the circuit, execute with Estimator, and post-process results
• Open a Runtime Session, submit a sequence of jobs, and observe calibration reuse across the session
• Inspect and modify the transpilation passes applied to a circuit for a specific backend
• Compare results with and without error mitigation enabled on the Estimator

Why take this course?

The Primitives and Qiskit Patterns represent the current state of the art for writing portable, maintainable quantum programs on IBM Quantum. Code written with the old Backend.run() interface does not work with the new Runtime architecture, so this transition is not optional for anyone working with IBM Quantum hardware.

IBM Learning is the authoritative source for this material: the course is written and maintained by the same team that designed the API. That means the explanations of design decisions are accurate and the worked examples reflect actual best practices.

For any developer who wants to go from quantum algorithm knowledge to working programs running on real IBM Quantum hardware, this course is the required bridge.