IBM Qiskit v2.X Developer (C9008400 / C1000-179) Practice Exam | PowerKram
IBM · Practice Exam · Cert C9008400 · Exam C1000-179

IBM Qiskit v2.X Developer – Associate Practice Exam

Prepare for the IBM Certified Quantum Computation using Qiskit v2.X Developer – Associate credential (exam C1000-179) with scenario questions across the full blueprint: quantum operations, circuit creation and visualization, running circuits with the Sampler and Estimator primitives, result retrieval, and OpenQASM. Each explanation links to the exact IBM Qiskit documentation page, with full timed simulation in Exam mode.

Start 24-hour free trial →
300+
Practice questions
8
Objective sections
2
Study modes
24h
Free trial

Qiskit v2.X Developer exam at a glance

Vendor
IBM
Certification code
C9008400
Exam code
C1000-179 (Fundamentals of Quantum Computing Using Qiskit v2.X Developer)
Certification
IBM Certified Quantum Computation using Qiskit v2.X Developer – Associate
Level
Associate (developer)
Questions
68
To pass
47 correct (about 69%)
Duration
90 minutes
Cost
$30 per attempt (indicative; varies by region)
Language
English
Badge
Digital badge issued via Credly on passing

Sources: IBM Training — C9008400 certification (exam C1000-179). Confirm current question count, cost, and objectives with IBM before scheduling.

About the Qiskit v2.X Developer certification

The IBM Certified Quantum Computation using Qiskit v2.X Developer – Associate credential validates that you can build and run quantum programs with the current Qiskit SDK and Qiskit Runtime. It is earned by passing a single exam — C1000-179 (note that C9008400 is the certification code, while C1000-179 is the exam you actually sit) — and confirms foundational quantum-computing literacy plus practical, service-oriented skills on IBM Quantum hardware.

This v2.X certification replaced the older v0.2X developer certification (C0010300, retired in 2025), and the change is more than cosmetic: the exam shifted decisively from the local execute paradigm to the cloud-based, service-oriented Qiskit Runtime primitives (Sampler V2 and Estimator V2), execution modes (job, session, batch), and OpenQASM 3. Candidates should be comfortable with the linear algebra behind quantum states and with Python-level circuit programming.

PowerKram’s practice questions map to IBM’s real exam sections and link every explanation to the exact IBM Qiskit documentation page it derives from, so a wrong answer becomes a specific page to read. For deeper background on the concepts around this exam, see the AI & machine learning guide.

Exam C1000-179 sections and weights

IBM publishes the eight exam sections and their weights below; they sum to 100%. Plan your study time roughly in proportion, and confirm the current split on IBM’s exam page, since IBM can update objectives over time.

Create quantum circuits

Build circuits including dynamic circuits (classical control flow), parameterized circuits, and layout considerations for real backends.

18%Heaviest
Perform quantum operations

Define Pauli operators, work with tensor products, and apply quantum gates and rotations, including global-phase effects.

16%
Run quantum circuits

Execute on IBM Quantum hardware with Qiskit Runtime: execution modes (job, session, batch), transpilation to the target ISA, and backend selection.

15%
Use the Sampler primitive

Configure and run Sampler V2 to obtain quasi-probability distributions over basis states, with shots and options.

12%
Use the Estimator primitive

Configure and run Estimator V2 to compute expectation values of observables, with resilience and error-mitigation options.

12%
Visualize circuits, measurements, and states

Interpret output with circuit drawings, histograms, and state visualizations (Bloch sphere, QSphere, density-matrix plots).

11%
Retrieve and analyze results

Work with the Runtime job object and result data structures, including retrieving results after disconnecting via the job ID.

10%
Operate with OpenQASM

Understand OpenQASM 3 syntax and export/import circuits between Qiskit and QASM 3.

6%

Source: IBM — exam C1000-179 objectives. Weights are IBM’s published figures and sum to 100%.

Who this exam is for

This is a technical, developer-focused associate credential for people who write quantum programs:

  • Quantum software developers building and running circuits in Qiskit on IBM Quantum hardware.
  • Researchers and students in quantum computing who want a recognized proof of applied Qiskit skills.
  • Python developers and ML/AI engineers moving into quantum and quantum-classical hybrid workflows.
  • Qiskit Advocates, for whom the v2.X certification is a requirement for higher program tiers.

Within IBM’s ecosystem, common companions on the AI and data side include the watsonx AI Engineer, watsonx Generative AI Engineer, and watsonx Data Scientist credentials. For the developer and AI-engineering roles this credential supports, with salary ranges and progression, see the AI engineer career path in our Career Hub.

What this practice exam delivers

Learn mode

Get the correct answer, the reasoning, and why each other option is wrong — immediately after each question. Built for the “which primitive, mode, or pass fits” decisions the exam leans on.

Exam mode

A timed run that mirrors the 68-question, 90-minute C1000-179 format and its ~69% pass bar, so pacing and recall feel familiar on test day.

Source-linked explanations

Every answer links to the exact IBM Qiskit documentation page — so you learn primitives, Runtime, and transpilation from IBM’s own docs, not just a memorized letter.

Score by section

Results break down by IBM’s eight sections — operations, circuits, running, Sampler, Estimator, visualization, results, and OpenQASM — so practice tells you exactly what to drill.

Sample Qiskit v2.X practice questions

Ten free scenario questions across the C1000-179 sections, each with a full explanation and a source link to the IBM Qiskit documentation it derives from. The complete bank is available with the 24-hour trial.

Question 1 · Use the Estimator primitive

A Qiskit developer wants to compute an expectation value of a Pauli observable for a parameterized circuit.

Which Qiskit primitive fits?

  1. The Sampler primitive, which returns quasi-probability distributions over basis states
  2. The Estimator primitive, which takes a circuit, parameters, and observables and returns expectation values
  3. Neither — parameters cannot be used with primitives
  4. A custom simulator outside Qiskit
Show answer & explanation

Correct: B — the Estimator primitive. Estimator is the Qiskit primitive for expectation values: it takes a circuit, parameter values, and observables and returns expectation values.

Why not the others: Sampler (A) returns distributions, not expectation values; primitives do support parameters (C); and a custom simulator (D) bypasses the official primitive interface.

Source: IBM Quantum — Primitives → Further reading: PowerKram — watsonx AI Engineer →
Question 2 · Create quantum circuits

A parameterized circuit must run with many different parameter values efficiently.

Which Qiskit pattern fits?

  1. Hard-code the parameter values and recompile each time
  2. Rebuild the circuit from scratch for every parameter value
  3. Build the circuit once with Parameter objects, then submit a parameter-value array to the primitive for efficient batched execution
  4. Avoid parameterization entirely
Show answer & explanation

Correct: C. Building the circuit once with Parameter objects and submitting a parameter-value array is Qiskit’s efficient sweep pattern — the primitive handles the values without recompilation.

Why not the others: recompiling per value (A), rebuilding from scratch (B), and avoiding parameterization (D) all waste compilation and defeat the primitive’s batching.

Source: IBM Quantum — Primitives (parameterized) →
Question 3 · Use the Sampler primitive

A Sampler run needs to configure shot count and result-level options.

Which approach configures shots and options on a Sampler run?

  1. Set global environment variables for each option
  2. Pass Sampler-specific options (shots, resilience, and similar) when invoking the primitive, per the Qiskit Runtime options API
  3. Modify Qiskit source code to change defaults
  4. Ignore the options and accept whatever defaults run
Show answer & explanation

Correct: B. The primitive options API is the Qiskit Runtime reference for configuring a run — you pass shots and other options when invoking Sampler.

Why not the others: environment variables (A), source edits (C), and ignoring options (D) all bypass the supported options API.

Source: IBM Quantum — Primitive options → Further reading: PowerKram — watsonx Generative AI Engineer →
Question 4 · Perform quantum operations

A developer needs to represent a two-qubit pure state for simulation.

Which Qiskit class fits?

  1. A plain Python list with no Qiskit structure
  2. DensityMatrix, which represents mixed states
  3. Operator, which represents unitary or general operators rather than states
  4. Statevector, which represents a pure quantum state as a complex amplitude vector in the computational basis
Show answer & explanation

Correct: D — Statevector. Statevector represents a pure state as a complex amplitude vector in the computational basis — the right class for a two-qubit pure state.

Why not the others: DensityMatrix (B) is for mixed states; Operator (C) represents operators, not states; a plain list (A) has none of Qiskit’s state API.

Source: IBM Quantum — qiskit.quantum_info → Further reading: PowerKram — watsonx Data Scientist →
Question 5 · Perform quantum operations

A circuit must act as a specific two-qubit unitary whose matrix form is known.

Which Qiskit technique fits?

  1. Use unitary decomposition (for example UnitaryGate or the two-qubit KAK decomposition) so Qiskit translates the matrix into gates supported by the target backend
  2. Apply the matrix directly to hardware without decomposition
  3. Round the matrix to the nearest identity
  4. Skip the gate and hope results are similar
Show answer & explanation

Correct: A. UnitaryGate / KAK decomposition is Qiskit’s way to realize an arbitrary unitary, translating the matrix into gates the backend supports.

Why not the others: applying a matrix directly to hardware (B), rounding to identity (C), and skipping the gate (D) all break correctness.

Source: IBM Quantum — Operators & decomposition →
Question 6 · Run quantum circuits

A Runtime workflow needs to run dozens of closely related circuits while keeping backend overhead low.

Which Runtime execution mode fits?

  1. Use Batch mode for unrelated single-shot jobs
  2. Submit each circuit as a completely independent job
  3. Avoid Qiskit Runtime and run locally only
  4. Use a Session so multiple primitive calls share the same backend context and benefit from lower per-call overhead
Show answer & explanation

Correct: D — a Session. Sessions group related primitive calls under one backend context, which is the Runtime reference for iterative workflows such as variational algorithms.

Why not the others: independent jobs (B) incur per-job overhead; local-only (C) forfeits real hardware; and Batch (A) is designed for independent jobs, not iterative ones.

Source: IBM Quantum — Execution modes (session/batch) →
Question 7 · Retrieve and analyze results

A Runtime job must have its results retrieved after the client disconnected mid-run.

Which capability fits?

  1. Wait on the command line without disconnecting, indefinitely
  2. Re-submit the whole workload because there is no persistence
  3. Use the job ID to fetch results via the Runtime service after reconnecting; Runtime persists jobs server-side
  4. Skip the job entirely
Show answer & explanation

Correct: C. Runtime persists jobs server-side, so you use the job ID to fetch results after reconnecting — the standard resume-after-disconnect path.

Why not the others: resubmission (B) wastes resources, blocking forever (A) is fragile, and skipping (D) forfeits the result.

Source: IBM Quantum — Monitor & retrieve jobs → Further reading: PowerKram — watsonx AI Engineer →
Question 8 · Run quantum circuits (transpilation)

A circuit runs poorly on real hardware because the default layout does not align with the backend’s coupling map.

Which transpilation technique fits?

  1. Use the transpiler’s layout and routing passes (with an appropriate optimization_level) to map logical qubits to well-connected physical qubits
  2. Disable transpilation and submit the logical circuit directly
  3. Pick random physical qubits without the coupling map
  4. Ignore the coupling map and hope the hardware compensates
Show answer & explanation

Correct: A. Layout and routing passes with a suitable optimization_level map logical qubits onto well-connected physical qubits — the transpiler’s reference approach for real hardware.

Why not the others: disabling transpilation (B), random mapping (C), and ignoring the coupling map (D) all break execution on a real device.

Source: IBM Quantum — Transpile →
Question 9 · Run quantum circuits (optimization)

A deep circuit accumulates many redundant gates after composition.

Which transpiler feature helps?

  1. Enable gate-cancellation and commutation passes in the transpiler’s staged pipeline to reduce gate count
  2. Rewrite the circuit from scratch by hand
  3. Accept the redundancy and run as-is
  4. Turn off the transpiler entirely
Show answer & explanation

Correct: A. Gate-cancellation and commutation passes in the transpiler’s staged pipeline reduce gate count — the reference optimization for redundant gates.

Why not the others: manual rewrites (B), running as-is (C), and turning off the transpiler (D) all forfeit the optimization.

Source: IBM Quantum — Transpiler passes →
Question 10 · Use the Estimator primitive (error mitigation)

A developer sees variance in expectation-value estimates that masks the signal of interest.

Which error-mitigation technique fits?

  1. Pretend the noise is not there
  2. Apply Zero-Noise Extrapolation (ZNE) by running the circuit at multiple noise scales and extrapolating to the zero-noise limit
  3. Discard noisy results at random
  4. Run the circuit only once and accept whatever you get
Show answer & explanation

Correct: B — ZNE. Zero-Noise Extrapolation runs the circuit at several noise scales and extrapolates to the zero-noise limit — a standard Qiskit error-mitigation technique, available as an Estimator resilience option.

Why not the others: ignoring noise (A), random discards (C), and single-shot runs (D) all fail to mitigate.

Source: IBM Quantum — Error mitigation & suppression → Further reading: PowerKram — AI & machine learning →

Keep going: Learning & Career resources

Quantum development is one of the most specialized niches in computing, and this IBM credential is a recognized proof point. Two PowerKram hubs back this exam.

Deep dive: exam facts, the v2.X shift, and a study plan

Exam facts and the cert-vs-exam codes

The credential code is C9008400, but the exam you sit is C1000-179 — a distinction worth getting right when you register through Pearson VUE. It’s 68 questions in 90 minutes, needing 47 correct (about 69%) to pass, in English, at roughly $30 per attempt (indicative; regional pricing varies). Passing issues a Credly digital badge. Confirm current details on IBM’s page before booking. Read the AI & ML guide →

Why v2.X is a real shift, not a version bump

The v2.X certification replaced the v0.2X developer exam (C0010300), which retired in 2025. The change reflects a major refactoring of the Qiskit stack: the old Aqua and Ignis components were unbundled, and the execution model moved from the local execute function to the cloud-based Qiskit Runtime primitives — Sampler V2 and Estimator V2 — with execution modes (job, session, batch). Studying older v0.2X material will misrepresent the current exam; prepare specifically for the v2.X, Runtime-centric paradigm.

Where the weight sits

No single section dominates, but circuit creation (18%), quantum operations (16%), and running circuits (15%) together are about half the exam, and the two primitives (Sampler 12%, Estimator 12%) add another quarter. Visualization (11%), results retrieval (10%), and OpenQASM (6%) round it out. Because the exam is applied, get hands-on: build parameterized and dynamic circuits, run them through both primitives in a session, transpile to a real backend’s ISA, and practice retrieving results by job ID.

Realistic study plan

Work through IBM’s official learning path and the Qiskit documentation for primitives, execution modes, transpilation, and error mitigation — the same pages linked in the explanations above — then build a small end-to-end workflow on IBM Quantum. Use PowerKram Learn mode to close gaps with sourced explanations while the rationale is fresh, then finish in Exam mode under the 90-minute, 47-to-pass pressure until you clear it consistently. AI & developer career paths →

Frequently asked questions about the Qiskit v2.X Developer exam

What is the difference between C9008400 and C1000-179?
C9008400 is the certification code for the IBM Certified Quantum Computation using Qiskit v2.X Developer — Associate. C1000-179 is the actual exam you take to earn it (Fundamentals of Quantum Computing Using Qiskit v2.X Developer). You register for and sit C1000-179.
What is the exam format and passing score?
Exam C1000-179 has 68 questions in 90 minutes, and you need 47 correct (about 69%) to pass. It's in English and costs roughly $30 per attempt (indicative; regional pricing varies). Passing issues a Credly digital badge. Confirm current details on IBM's site.
What are the exam sections and weights?
IBM publishes eight sections that sum to 100%: Create quantum circuits (18%), Perform quantum operations (16%), Run quantum circuits (15%), Use the Sampler primitive (12%), Use the Estimator primitive (12%), Visualize circuits/measurements/states (11%), Retrieve and analyze results (10%), and Operate with OpenQASM (6%).
How is v2.X different from the older v0.2X exam?
The v2.X certification replaced the v0.2X exam (C0010300), which retired in 2025. It moved from the local execute paradigm to the cloud-based Qiskit Runtime primitives (Sampler V2 and Estimator V2), execution modes (job, session, batch), and OpenQASM 3. Prepare specifically for the v2.X, Runtime-centric material.
Who should take this exam?
It's aimed at quantum software developers, researchers, and students who build and run circuits in Qiskit on IBM Quantum hardware, plus Python and AI/ML developers moving into quantum. Comfort with the linear algebra behind quantum states and Python-level circuit programming is expected.

Start your free 24-hour Qiskit v2.X practice trial

Full access to 300+ questions across every section, both study modes, and source-linked explanations. No credit card required.

Start free trial →