# A Developer's Field Guide to Amazon Braket

By Christian Perez, published 2026-07-17

Canonical: https://quantumdev.io/blog/a-developers-field-guide-to-amazon-braket/

A guided tour of the Amazon Braket console, page by page. What each button does, when you'd use it, and how to run your first task on a real quantum computer.

## Who is this guide for, and how should you read it?

If you have an AWS account and a little curiosity about quantum computing, you already have everything you need to run a program on a real quantum processor right now. You don't need a physics degree, you don't need to own a dilution refrigerator, and you don't need to email a national lab. All you need is your browser, the AWS Console, and a few minutes to explore.

This guide is a click-by-click walk through the **Amazon Braket** console. Amazon Braket is the fully managed quantum computing service on AWS. I'm going to open every panel, press every button, and tell you what happens and why it matters.

Where helpful, I'll drop in a few lines of Python from the Braket SDK so you can go from looking at the console to "my circuit just ran on trapped ions in a lab in Europe."

A few conventions:

- **Screenshots** mark each stop on the tour. Every image caption describes exactly what you're looking at, so you can follow along in your own console.
- `Try it` callouts are the "put the guide down and go do this" moments.
- **Tables** are your cheat sheets (device specs, pricing, instance types). Skim them, then come back.
- Everything here reflects the Braket console as of **mid-2026**. Quantum hardware moves _fast_ — devices come and go monthly (there's a whole section on that), so treat specific device names as a snapshot.

> **A note on cost before you touch anything:** Braket has no flat subscription. Simulators and quantum processors are pay-as-you-go, and the local simulator that ships with the SDK is **free**. You can run this entire tour's "hello world" for pennies and I'll show you how to set a hard spending limit so you never get surprised. Read the [Cost controls](#10-cost-controls) section before you submit to real hardware.

## How does Braket work, in 30 seconds?

Braket wraps three things behind one console and one SDK:

1. **Simulators** — classical computers pretending to be quantum ones. Perfect for development. Some run locally (free), some run on-demand in the cloud.
2. **QPUs (Quantum Processing Units)** — this is the real thing. Trapped ions, superconducting circuits, neutral atoms from several hardware companies, all reachable through the same API.
3. **What brings it all together** — managed Jupyter notebooks, hybrid quantum-classical job orchestration, result storage in S3, cost tracking, and access controls.

The workflow Braket is built around is a simple loop: **Build → Test → Run → Analyze.**

![Diagram of the Braket loop: Build (design your circuit), Test (run on a simulator), Run (submit to a QPU) and Analyze (read results from S3), with an arrow labelled iterate leading from Analyze back to Build.](https://quantumdev.io/blog/media/image-36b85961edab9ae5cc7ca0c1cccfb48fe4cdbe11-1150x208-webp-960.webp)

You build and test for virtually $0 and you only pay real money at the "Run on a QPU" step. Keep that loop in mind. The whole console is organized around it.

![The Amazon Braket landing page in the AWS console, with a How it works diagram of Build, Test, Run and Analyze, and panels for getting started, Quantum Embark, pricing and more resources.](https://quantumdev.io/blog/media/image-6b397abb4bef14b430a5027587202c013e87ca9f-2974x1808-webp-960.webp)

## 1. Getting In: Finding Braket and Flipping On the Switch

### Finding the service

Open the AWS Console and type **Braket** in the top search bar. Amazon Braket shows up under **Services**, described as a "Service for exploring, evaluating, and experimenting with quantum computing."

The search panel also surfaces three Braket **features** directly (_Braket Direct_, _Permissions and Settings_, and _Service Dashboard)_ so you can jump straight to a subsection. Click the star to pin Braket to your console favorites; you'll be back.

![The AWS console search for Braket, with Amazon Braket first among the services, and Braket Direct, Permissions and Settings and Service Dashboard listed as features.](https://quantumdev.io/blog/media/image-fd953fd75eb7d2286ec8654c11414a888fb70163-1876x1636-webp-960.webp)

### The left-nav: your whole map

Once inside, everything hangs off the left navigation menu. Here's the entire console in one table. This is also the map for the rest of the guide.

| Nav item | What it's for | Covered in |
| --- | --- | --- |
| **Dashboard** | At-a-glance widgets: notebooks, jobs, announcements, preferred device | Section 2 |
| **Devices** | Browse every simulator and QPU; inspect specs, calibration, cost | Section 3 |
| **Notebooks** | Managed JupyterLab instances, pre-loaded with the SDK | Section 4 |
| **Hybrid jobs** | Orchestrated quantum-classical workloads with priority device access | Section 5 |
| **Quantum tasks** | The atomic unit of work — one circuit + shots submitted to one device | Section 6 |
| **Algorithm library** | 11 ready-to-run textbook algorithms in Python | Section 7 |
| **Braket Direct** | Reservations, expert office hours, experimental hardware features | Section 8 |
| **Administration → Permissions and settings** | Enable third-party devices; manage IAM execution roles | Section 1 & 10 |
| **Administration → Spending limits** | Hard dollar caps per QPU | Section 10 |
| **Announcements** | New devices, retirements, feature launches | Section 11 |

![The Amazon Braket left-hand navigation: Dashboard, Devices, Notebooks, Hybrid jobs, Quantum tasks, Algorithm library, Braket Direct, Administration with Permissions and settings and Spending limits, and Announcements.](https://quantumdev.io/blog/media/image-6caa698e4186c7277897e495f76432e9b19afcc8-2218x1150-webp-960.webp)

### Enable third-party devices: the one-time setup

Before you can send a workload to any non-AWS device (IonQ, IQM, QuEra, Rigetti, AQT), you have to accept the third-party hardware terms once. Go to:

**Administration → Permissions and settings**.

On the **General** tab you'll find **Enable third-party devices**. Flipping this to _Enabled_ acknowledges that when you use a partner's hardware, your circuit content is transferred to that provider outside AWS facilities for processing. No acceptance, no QPU access.

![The General tab of Permissions and settings, where Enable third-party devices shows Enabled above the terms for sending circuits to third-party hardware providers.](https://quantumdev.io/blog/media/image-fc7beceb917672910650658252845fc70426fdd9-3426x1408-webp-960.webp)

### Execution Roles (the IAM plumbing)

The **Execution roles** tab is where Braket confirms it has the IAM roles it needs. There are three to know about:

- **Service-linked role** (`AWSServiceRoleForAmazonBraket`) — lets Braket act on your behalf. Braket creates this automatically; you'll see a green "Service-linked role found" banner.
- **Notebook access role** — an IAM role with the `AmazonBraketFullAccess` policy so notebook instances can call Braket operations. Use **Verify existing roles** to confirm you have one.
- **Hybrid jobs execution role** — carries the `AmazonBraketJobsExecutionPolicy`, the minimum permissions a hybrid job needs to run.

If any are missing, the page offers a one-click **Create default role**. For a first-time account, click through all three and you're provisioned.

![The Execution roles tab of Permissions and settings: the service-linked role is found, and the notebook access role and hybrid jobs execution role each offer Verify existing roles and Create default role.](https://quantumdev.io/blog/media/image-23eac79434c161bce55720b7bb0ad4cca0e9be98-3432x1350-webp-960.webp)

> `Try it` — In your AWS account, spend your first two minutes here: enable third-party devices, then verify all three execution roles. It's the only mandatory setup, and skipping it is the #1 reason a first QPU submission fails.

## 2. The Service Dashboard

Click **Dashboard** for the mission-control view. It's a grid of widgets you can rearrange, remove, or add to with **Add widgets** (and **Reset to default layout** if you make a mess):

- **Active notebooks** and **Recent hybrid jobs** — quick status, with "Create" shortcuts when empty.
- **Announcements** — the live feed of device launches and retirements (more in [§11](#11-announcements-how-to-stay-current)).
- **Community support** — direct links to the AWS Quantum Computing Blog, the Quantum Computing Stack Exchange, and AWS re:Post.
- **Device** — pin a **preferred device** so its live properties surface right here on the dashboard.
- **Resources** — links to Quantum Embark (AWS's paid advisory program for Enterprise), the Braket Learning Plan, and the developer guide.

![The Braket service dashboard, with widgets for active notebooks, recent hybrid jobs, announcements, community support, a preferred device and resources.](https://quantumdev.io/blog/media/image-ae756e0a7dcf67fef89e79c36696cfffe0c00bff-3420x1776-webp-960.webp)

> Try it — Hit **Set a preferred device** and pick a simulator like SV1. Now your dashboard always shows you a live device you can reach for free.

## 3. Devices: the Heart of Braket

This is one of the pages you'll open most. **Devices** lists every simulator and QPU you can reach, with provider, device name, live status, and a one-line description.

### The current fleet

Out of the box you see the **online** devices. As of this writing that's nine — two AWS simulators and seven QPUs spanning four qubit technologies:

![The Devices page listing nine devices: the SV1 and DM1 simulators from AWS and QPUs from AQT, IonQ, IQM, QuEra and Rigetti, all online except IonQ Forte Enterprise 1.](https://quantumdev.io/blog/media/image-f7acbbcd1de633021c5d91a69bd5df54b61180d4-3430x1208-webp-960.webp)

Three status values are very important: **ONLINE** (accepting tasks now though QPUs still have availability windows), **OFFLINE** (temporarily unavailable), and **RETIRED** (gone for good).

### The fleet moves fast: "Show retired devices"

Toggle **Show retired devices** and the list jumps from 9 to 28. This is the single best lesson the Devices page teaches: _quantum hardware is a moving target._ The retired list is a graveyard of an entire industry's iteration.

![The Devices page with Show retired devices switched on, listing 28 devices, most of them retired, among them D-Wave annealers, Rigetti Aspen machines, IonQ Harmony and Aria, OQC Lucy, Xanadu Borealis and the TN1 simulator.](https://quantumdev.io/blog/media/image-92325b657825deeac6692ea2cbcc9f29480e9059-3430x1708-webp-960.webp)

The takeaway for anyone building on Braket: **program against device _properties_, not device _names_.** Query capabilities at runtime (qubit count, native gates, connectivity) so your code survives the next hardware refresh.

> `Try it` — Toggle "Show retired devices" and just read the descriptions. You're looking at the last five years of the quantum industry in one scrollable list.

### Inside a device: the detail page

Click any device name to open its detail page. The layout is consistent across the fleet, so learn it once. Up top is a **Summary** card:

- **Status**, **Device ARN** (the string your code needs. Copy it here), and **Spending limit**.
- Three **queue depth** counters: _Tasks_, _Priority tasks_, and _Hybrid jobs_. These tell you how many workloads are ahead of yours right now.
- Action buttons: **Reserve device** (jump the queue via Braket Direct), **Open notebook** (spin up a notebook pre-pointed at this device), and a refresh icon.

Below that, up to four tabs. Let's use two real devices to see the range.

**QuEra Aquila — a 256-qubit analog machine.** Aquila is a neutral-atom device that operates in _analog_ mode (continuous evolution of a Hamiltonian rather than discrete gates). Its detail page shows the hardware provider (QuEra, Boston), the Region (`us-east-1`), and, importantly, its cost and availability:

![The detail page for QuEra Aquila, a 256-qubit analog neutral-atom QPU in us-east-1: online with 5 tasks queued, priced at $0.30 a task plus $0.01 a shot or $2,500 an hour reserved, with its weekly availability windows.](https://quantumdev.io/blog/media/image-212156c7b7638757f654dc38876121cc79bf02cc-2348x1648-webp-960.webp)

The **Calibration** tab is where hardware honesty lives. For Aquila you get device geometry and error characteristics — 256 sites, a 75 µm × 76 µm lattice, 4 µm spacing, position resolution down to 0.01 µm, plus filling, vacancy, and detection error rates — with a **Device geometry / Control fields / JSON** switch so you can grab the raw numbers programmatically. Every calibration table is timestamped ("Last updated…") because these values drift and are re-measured regularly.

![Aquila's Calibration tab, a timestamped table of device geometry and error rates: 256 sites, a 75 by 76 micrometre lattice, and filling, vacancy, atom loss and detection errors.](https://quantumdev.io/blog/media/image-8b697e4b93535206f25cfe8fcf1595f4dfa3c0fe-1692x1504-webp-960.webp)

The **Experimental capabilities** tab exposes cutting-edge features you enable per-task through the SDK. For Aquila, _local detuning_, _tall geometries_, and _tight geometries_ (ways to push past the standard operating modes).

![Aquila's Experimental capabilities tab, offering local detuning, tall geometries and tight geometries.](https://quantumdev.io/blog/media/image-4844b75e2002f772502f9666a0d1b4213383a5ce-2854x1250-webp-960.webp)

**AQT IBEX Q1 — a 12-qubit gate-model machine.** On a gate-based QPU, the **Native Gates** tab lights up. It lists the exact gate set the hardware executes natively. Everything else in your circuit gets compiled down to these. For AQT's ion trap that's `prx` (a phase-RX gate), `xx` (an Ising XX coupling gate), and `rz` (a Z-axis rotation). Notice this device lives in `eu-north-1` This is a reminder that **QPUs are Region-specific.**

![The Native Gates tab for AQT IBEX Q1, a 12-qubit ion-trap QPU in eu-north-1, listing prx, xx and rz, under a banner saying no spending limit is set.](https://quantumdev.io/blog/media/image-7f836a09aa560d0d0b653f21ad114e70ddaa2ec4-2868x1422-webp-960.webp)

Here's how you'd pull all of that from code instead of the console:

```python
from braket.aws import AwsDevice

# Copy the ARN straight from the device page's Summary card
aquila = AwsDevice("arn:aws:braket:us-east-1::device/qpu/quera/Aquila")

print(aquila.status)                       # ONLINE / OFFLINE
print(aquila.properties.paradigm)          # qubit count, geometry, etc.
# Gate-model devices expose their native gate set:
garnet = AwsDevice("arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet")
print(garnet.properties.paradigm.nativeGateSet)
```

| Tab | Appears on | What it tells you |
| --- | --- | --- |
| **Details** | All devices | Provider, region, qubits, cost, availability windows |
| **Calibration** | All devices | Live, timestamped error rates and topology |
| **Native Gates** | Gate-model QPUs only | The exact gate set your circuit compiles to |
| **Experimental capabilities** | Select devices | Per-task opt-in features (dynamic circuits, geometry tricks) |

> `Try it` — Open SV1 (free) and a QPU like IQM Garnet side by side. Compare their Calibration tabs. The simulator is "perfect"; the QPU is informatively imperfect.

## 4. Notebooks: your Managed Jupyter Cockpit

You _can_ run Braket from your laptop with `pip install amazon-braket-sdk`. But another option is a **managed notebook** like a JupyterLab instance AWS spins up with the Braket SDK and the major quantum frameworks already installed.

Click **Notebooks** and Braket offers two paths.

![The Notebooks page, offering a standard notebook with a Create button and an advanced notebook with a Configure button.](https://quantumdev.io/blog/media/image-9aafe0fe27255170f9f9cdeb2b51ecc6670f51e9-3434x1276-webp-960.webp)

|  | **Standard notebook** | **Advanced notebook** |
| --- | --- | --- |
| Setup | One click | 5-step wizard |
| Compute | `ml.t3.medium` | EC2 / HPC / GPU, your choice |
| Pre-installed | Braket SDK, CUDA-Q, PennyLane, Qiskit | Everything in Standard, plus… |
| Extras | JupyterLab extensions, example algorithms | Custom IAM, VPC, KMS encryption, custom GitHub repos |
| Best for | Learning, prototyping | Team environments, private networking, big compute |

### The one-click standard notebook

Choosing **Standard → Create** pops a small modal: name your instance (Braket prefixes it with `amazon-braket-`, max 35 characters, hyphens allowed, no spaces) and choose whether to enable the **Notebook inactivity manager.**  This is a helpful watchdog that stops the instance after idle time so you stop paying for compute you're not using.

![The Create a notebook dialog: a name after the fixed prefix amazon-braket-, and the notebook inactivity manager set to enable or disable.](https://quantumdev.io/blog/media/image-5c435fcb05bf599816a3a095db35096706f1ff08-1614x646-webp-960.webp)

> **Cost reality check:** A notebook instance is billed like the underlying EC2 instance for as long as it's _running_, whether or not you're using it. Enable the inactivity manager, or make a habit of **Stop**-ping the instance when you walk away. This is the most common source of a surprise Braket bill and it's not the quantum part.

### The advanced notebook wizard, step by step

Click **Advanced → Configure** for the full five-step wizard. This is where teams tailor an environment.

![The five steps of the advanced notebook wizard: 1, general settings (name, theme, idle); 2, notebook configuration (instance type, volume, repository); 3, access permissions (IAM, root, KMS); 4, network access (VPC); 5, review and launch.](https://quantumdev.io/blog/media/image-997c821f19d2d8084c05df2ea2df10587bf9ff5e-1120x160-webp-960.webp)

**Step 1 — General settings.** Name, light/dark visual mode, and the same inactivity manager toggle.

![Step 1 of the notebook wizard, General settings: the notebook name, a light or dark visual mode and the inactivity manager.](https://quantumdev.io/blog/media/image-3c8a88bfe8fed7e2875e9752ee23ca51c2f4aa0e-2852x1120-webp-960.webp)

**Step 2 — Notebook configuration.** Pick your compute. This is the step that decides your hourly cost and how much classical horsepower sits next to your quantum code.

You also set a **volume size** (5 GB up to 16 TB) and can **import a GitHub repository** so your notebook starts with your team's code already cloned.

![Step 2 of the notebook wizard, Notebook configuration: Standard (ml.t3.medium), High performance (ml.c5.xlarge), GPU accelerated (ml.g4dn.xlarge) or a custom instance type, a 5 GB volume and an optional GitHub repository.](https://quantumdev.io/blog/media/image-2adac3eb2ea19dd3abc27e6e88bc005d1efedff2-2862x1360-webp-960.webp)

**Step 3 — Access permissions.** Choose the IAM role the notebook assumes (e.g., the default `AmazonBraketServiceSageMakerNotebookRole`), decide on **root access**, and optionally supply a **KMS key** to encrypt the volume.

![Step 3 of the notebook wizard, Access permissions: the existing role AmazonBraketServiceSageMakerNotebookRole, root access enabled and no custom encryption key.](https://quantumdev.io/blog/media/image-23609b70c6cb3535fbcc941c0aca1ab330667cc4-2864x1442-webp-960.webp)

**Step 4 — Network access.** Attach the notebook to a **VPC** (or "No VPC" for a public instance). This is how you keep a notebook on a private network with no internet exposure.

![Step 4 of the notebook wizard, Network access, with the VPC set to No VPC.](https://quantumdev.io/blog/media/image-0390b3c22df1112b578100fb4c762a0b01d47d54-2868x682-webp-960.webp)

**Step 5 — Review and launch.** A tidy summary of every choice, plus optional resource **Tags** (great for cost allocation). Hit **Launch** and Braket provisions the instance.

![Step 5 of the notebook wizard, Review and launch: the notebook amazon-braket-demo on ml.t3.medium with a 5 GB volume, root access and no VPC, with optional tags and a Launch button.](https://quantumdev.io/blog/media/image-78ba215cd48e0c4458f3a8f8578b8ba5a76b6664-2860x1622-webp-960.webp)

### Your first circuit (once the notebook opens)

Open the launched notebook, start a `conda_braket` kernel, and here's the genuine "hello, world" of quantum computing: a **Bell state** on the free local simulator:

```python
from braket.devices import LocalSimulator
from braket.circuits import Circuit

# Build: an equal superposition of |00> and |11>
bell = Circuit().h(0).cnot(0, 1)
print(bell)

# Test: run on the free local simulator (up to ~25 qubits)
result = LocalSimulator().run(bell, shots=1000).result()
print(result.measurement_counts)      # ~ Counter({'00': 503, '11': 497})
```

Two entangled qubits, measured a thousand times, coming out as roughly half `00` and half `11` — and never `01` or `10`. That's entanglement, and it cost you nothing. When you're ready to leave the simulator, you change exactly one line: the device. THIS is the whole point of Braket's design. We'll do that in [§6](#6-quantum-tasks-the-atomic-unit-of-work).

## 5. Hybrid Jobs: Quantum-Classical, Orchestrated

Most useful near-term quantum algorithms (QAOA, VQE, quantum machine learning) are _hybrid_: a classical optimizer runs a loop, and inside each iteration it calls a QPU. **Hybrid Jobs** is Braket's managed orchestration for exactly that pattern. It provisions a classical instance to run your driver code, gives your job **priority access** to the chosen QPU (so you're not re-queuing every iteration), streams metrics, checkpoints progress, and tears everything down when you're done.

The **Hybrid jobs** page starts empty, with **Create hybrid job** front and center. Creating one is a five-step wizard.

![The empty Hybrid Jobs page, with a Create hybrid job button.](https://quantumdev.io/blog/media/image-ffa9c58a206f697553abb473e655aa3edfd9289e-3430x1116-webp-960.webp)

**Step 1 — Specify an algorithm.** Upload a Python script from your computer or point at one in S3, set the **entry point** (the function invokes when the job starts), and optionally mark it **Zipped**. You can also expand **Hyperparameters** (values passed into your algorithm) and **Input data** (extra files staged for the job).

![Step 1 of creating a hybrid job, Specify an algorithm: a zipped Python file uploaded from the computer, its entry point, and optional hyperparameters and input data.](https://quantumdev.io/blog/media/image-cf0ee5ea08150c4fb26a8aa713a6c1928644ca98-3414x1718-webp-960.webp)

**Step 2 — Set hybrid job settings.** Name the job (defaults to `braket-job-default`) and, under **Advanced settings**, choose the execution role and the **default S3 bucket** where Braket stashes your code, inputs, outputs, and checkpoints.

![Step 2 of creating a hybrid job: the job name braket-demo, the AmazonBraketJobsExecutionRole role and the default S3 bucket.](https://quantumdev.io/blog/media/image-7c65e57b6659310eefbb89c2ed7c75db26536d89-3430x1264-webp-960.webp)

**Step 3 — Configure an environment.** Pick the container your code runs in. The base images ship with the Braket SDK, Python, and PennyLane; the TensorFlow and PyTorch variants add those frameworks (and CUDA); CUDA-Q adds GPU-accelerated simulation; or bring your own container (BYOC).

![Step 3 of creating a hybrid job, Configure an environment: PennyLane, PennyLane with TensorFlow, PennyLane with PyTorch, CUDA-Q, or a custom container.](https://quantumdev.io/blog/media/image-d3538f3cc648ea185a8e3fe462e3c909126074b3-3436x1374-webp-960.webp)

| Environment | Adds | Reach for it when… |
| --- | --- | --- |
| **PennyLane** | Core Braket SDK + PennyLane | Standard variational algorithms |
| **PennyLane + TensorFlow** | TF + CUDA | ML/AI-flavored quantum work |
| **PennyLane + PyTorch** | PyTorch | Computer-vision / NLP-style pipelines |
| **CUDA-Q** | NVIDIA CUDA-Q | GPU-accelerated quantum simulation |
| **Custom (BYOC)** | Your Docker image | You need exact, reproducible deps |

**Step 4 — Configure the execution.** Under **Quantum compute settings** you pick the **Device** your job gets priority on (or use an _embedded simulator_ inside the classical instance), and optionally attach a **Reservation** to bypass queues entirely. Under **Classical compute settings** you size the driver instance. Then set a **Stopping condition** (max runtime default to 5 days) and optionally configure **Checkpoints** and **Outputs**.

![Step 4 of creating a hybrid job, Configure the execution: the quantum device and an optional reservation, a Standard ml.m5.large instance, 5 GB of extra storage, a maximum runtime of 5 days, and optional checkpoints and outputs.](https://quantumdev.io/blog/media/image-0119078b0bfb2718c19058ff941a38d4589c7d21-2934x1704-webp-960.webp)

| Classical instance | Specs | Use |
| --- | --- | --- |
| Standard | `ml.m5.large` — 2 vCPU, 8 GiB | Most driver loops |
| GPU accelerated | `ml.g4dn.xlarge` — 4 vCPU, 16 GiB, 1× NVIDIA T4 | Embedded GPU simulators, ML |
| Advanced selection | any supported type | Full control |

**Step 5 — Review and create.** Everything in one screen from algorithm source, and role, to environment, hardware, and device ARN. Notice you can build and validate an entire hybrid job pointed at the **local simulator** (`local:braket/default-simulator`) so you never spend a cent debugging orchestration before you point it at real hardware.

![Step 5 of creating a hybrid job, Review and create: the job braket-demo on ml.m5.large with the PennyLane runtime, pointed at the local simulator local:braket/default-simulator.](https://quantumdev.io/blog/media/image-66684fb0bee5aed62aafae473654f17f8ccc2a85-2650x1346-webp-960.webp)

The console wizard mirrors a decorator-based API. In a notebook, the same job is a few lines:

```python
from braket.jobs import hybrid_job
from braket.devices import LocalSimulator

@hybrid_job(device="local:braket/default-simulator")
def run_job():
    from braket.circuits import Circuit
    circ = Circuit().h(0).cnot(0, 1)
    return LocalSimulator().run(circ, shots=1000).result().measurement_counts

job = run_job()          # Braket provisions, runs, and tears down
print(job.result())
```

> `Try it` — Create a hybrid job pointed at the local simulator with the tiny script above. It costs nothing and teaches you the entire lifecycle — provisioning, running, checkpointing, results in S3 — before real hardware is involved.

## 6. Quantum Tasks: The Atomic Unit of Work

A **quantum task** is the smallest thing Braket runs: one program (a circuit, an annealing problem, or an analog schedule) submitted to one device for a set number of **shots** (repetitions). Every simulator run, every QPU run, every iteration inside a hybrid job; all of it is quantum tasks under the hood. The **Quantum tasks** page is your run history.

A banner at the top makes a point worth remembering (YET AGAIN): **QPUs are Region-specific.** A task for IQM Garnet must be submitted in `eu-north-1`; a task for QuEra Aquila in `us-east-1`. If your task list looks empty, check your Region first.

![The Quantum Tasks page listing four completed tasks on IQM Garnet and IQM Emerald in eu-north-1, under a note that QPUs are Region-specific.](https://quantumdev.io/blog/media/image-27632db568eb6ba1a4ca268f502822f9bec821ce-3430x1084-webp-960.webp)

Click a task to open its detail page. This is the receipt for a single run:

- **Quantum task ARN** and **Device ARN** — the unique identifiers.
- **Status** — `CREATED → QUEUED → RUNNING → COMPLETED` (or `FAILED`/`CANCELLED`).
- **Successful shots** — e.g., `100 / 100 (100%)`.
- **Queue position** — where you sit when queued.
- **Results** — a **View in S3** link; raw measurement data always lands in your Braket S3 bucket.
- **Reservation ARN** / **Hybrid job ARN** — populated if the task ran under either.
- Tabs for a **Results explorer** and **Tags**.

![A quantum task's detail page: a completed program on IQM Garnet with 100 of 100 shots successful, a View in S3 link to the results, and tabs for the Results explorer and Tags.](https://quantumdev.io/blog/media/image-4aab2237dba5157d5a4156fc1d226c76b6ee3753-3430x1524-webp-960.webp)

Now the one-line change that turns your free Bell-state test into a real quantum-hardware run — swap `LocalSimulator()` for an `AwsDevice` ARN. This is the moment the guide has been building toward:

```python
from braket.aws import AwsDevice
from braket.circuits import Circuit
from braket.tracking import Tracker      # near-real-time cost tracking

bell = Circuit().h(0).cnot(0, 1)

# On-demand cloud simulator (SV1) — cheap, region-agnostic ARN:
sv1 = AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")

# ...or a real QPU (must be in that device's Region!):
garnet = AwsDevice("arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet")

with Tracker() as tracker:
    task = garnet.run(bell, shots=100)          # returns immediately
    print(task.state())                          # QUEUED / RUNNING / COMPLETED
    counts = task.result().measurement_counts    # blocks until done
    print(counts)

print(tracker.quantum_tasks_statistics())        # shots, tasks, duration
print(tracker.qpu_tasks_cost())                  # estimated $ before the bill
```

The `Tracker` context manager is worth its weight in gold. It gives you a **maximum cost estimate in USD in near-real-time**, so you know what a run cost before the monthly bill confirms it.

> `Try it` — Run the Bell state on `SV1` first (cloud simulator, cents). When the counts look right, change one line to a QPU ARN and watch your task move through `QUEUED → RUNNING → COMPLETED` on the Quantum tasks page. Congratulations — you just used a real quantum computer.

## 7. Algorithm Library: 11 Ready-to-Run Classics

If you learn better by reading working code, **Algorithm library** is the best page on the console. It's a catalog of pre-built, textbook quantum algorithms, each written in Python, each with a **GitHub** link, each runnable in a managed notebook via **Open notebook**. No blank-page problem. You start from a correct implementation and modify.

![The Algorithm library's 11 algorithms, each with a GitHub link: Bernstein-Vazirani, Deutsch-Jozsa, Grover's, QAOA, the quantum circuit Born machine, the quantum Fourier transform, quantum phase estimation, quantum walk, Shor's, Simon's and a violation of Bell's inequality.](https://quantumdev.io/blog/media/image-6c27d6bcd9e40658695fb2349a05c2202ab177c5-1686x1646-webp-960.webp)

| Algorithm | What it demonstrates |
| --- | --- |
| **Bernstein–Vazirani** | The first algorithm to beat classical for a specific problem — oracle separation |
| **Deutsch–Jozsa** | An early, clean quantum-vs-classical advantage |
| **Grover's** | Quadratic speedup for unstructured search (√N vs N) |
| **QAOA** | Hybrid optimization — the workhorse of the NISQ era |
| **Quantum Circuit Born Machine** | Variational generative modeling |
| **Quantum Fourier Transform** | The subroutine behind Shor's and phase estimation |
| **Quantum Phase Estimation** | Eigenvalue estimation — foundational to many algorithms |
| **Quantum Walk** | The quantum analog of a random walk |
| **Shor's** | Polynomial-time integer factoring — the famous one |
| **Simon's** | Exponential separation; a precursor to Shor's |
| **Violation of Bell's Inequality** | Proof that entanglement is real, in code |

> `Try it` — Open **Grover's algorithm**, run it on the local simulator, then change the "marked" item and watch the probability concentrate on your new target. It's the most satisfying five minutes in the console.

## 8. Braket Direct: Skip the Line and Go

**Braket Direct** is a hub of three "power-user" programs bundled together: dedicated hardware access, human expertise, and bleeding-edge features.

![The Braket Direct page: reservations; expert advice from Braket office hours, IonQ, QuEra, Rigetti and the Advanced Solutions Lab; and experimental capabilities on IQM Emerald, IQM Garnet and QuEra Aquila.](https://quantumdev.io/blog/media/image-2efcd7cdf9fa7da33e6ace5480e3197607766fbf-1686x1506-webp-960.webp)

**Reservations** give you _exclusive_ access to a specific QPU for a block of time, so your workloads don't wait behind anyone else's. Key facts (verified against the Braket developer guide):

- Available in **1-hour increments** for all Braket devices.
- **Cancellable up to 48 hours in advance** at no charge; otherwise you pay for the reserved block regardless of how much you use it.
- Queue tasks and jobs _in advance_ against your **Reservation ARN**, or submit live during the window.
- IonQ perk: reservations raise the per-circuit gate limit to 5,000 (vs. 2,000 on-demand) and lower the error-mitigation minimum shot count to 500 (vs. 2,500).

Clicking **Reserve device** opens a request form — your name and email, a description of your workload, a duration (1–5+ hours), two or more candidate dates, and an option for a free 30-minute prep session with a Braket expert.

![The Create reservation form: name, email, a description of the workload, a duration from 1 to 5 or more hours, two or more candidate dates, and an optional 30-minute prep session.](https://quantumdev.io/blog/media/image-95f4a6f319808e69944b73e179646f0819d6803d-1216x1954-webp-960.webp)

**Expert advice** connects you to real humans: free weekly **Braket office hours** (30-minute 1:1 slots), plus dedicated channels to **IonQ, QuEra, and Rigetti**, and the **Advanced Solutions Lab (ASL)** for deeper collaborative research engagements.

**Experimental capabilities** surfaces next-generation features with limited availability — enabled per-task through the SDK. In this snapshot: **dynamic circuits** (mid-circuit measurement and feed-forward) on **IQM Emerald** and **IQM Garnet**, and **local detuning / tall geometries / tight geometries** on **QuEra Aquila**.

| Program | What you get | Cost model |
| --- | --- | --- |
| **Reservations** | Exclusive device access, no queue | Per-hour, billed for the block |
| **Expert advice** | Office hours, provider channels, ASL | Office hours free; ASL varies |
| **Experimental capabilities** | Early hardware features | Per-task, standard device pricing |

> `Try it` — Even if you never reserve hardware, book a **Braket office hours** slot. Thirty free minutes with an AWS quantum specialist is the highest-leverage button on this entire page.

## 9. Program Sets: Batch many circuits into one task

A mid-2026 addition worth calling out: **Program Sets.** Historically each circuit was its own quantum task with its own per-task fee and its own trip through the queue. A program set lets you bundle **up to 100 unique circuits** _or_ a single **parametric circuit with up to 100 parameter settings** into **one** quantum task. Braket handles compiling and running the whole package on the QPU, minimizing the gap between executions and the per-task overhead.

Why you care:

- **One per-task fee** across every circuit in the set (you still pay per shot).
- **Less queue waiting** — one submission instead of a hundred.
- Ideal for **variational algorithms, classical shadows, and quantum machine learning**, where you sweep a parameter or run a batch of related circuits.

Program sets are available across the gate-based devices. If your workload is "run this circuit 100 times with different angles," this is the feature that makes it cheap and fast.

## 10. Cost Controls

Quantum hardware is metered, and QPU time is not cheap. Braket gives you three independent guardrails. Use all of them.

### How does Braket charge?

You pay for what you run:

| Resource | How it's billed |
| --- | --- |
| **Local simulator** (in the SDK) | **Free** |
| **On-demand simulators** (SV1, DM1) | Per **minute** of simulation time |
| **QPUs** | Per **task** + per **shot** (rates vary by device) |
| **Reservations** | Per **hour** of the reserved block, regardless of use |
| **Notebooks / hybrid job classical compute** | Per the underlying EC2 instance, while running |

A concrete QPU example straight off the device page: QuEra Aquila: **$0.30 per task + $0.01 per shot** on-demand, or **$2,500 per hour** reserved. So a 100-shot Aquila task runs about `$0.30 + 100 × $0.01 = $1.30`. Rates differ per device and change over time, so always confirm current numbers on the [Amazon Braket pricing page](https://aws.amazon.com/braket/pricing/) or the device's Details tab before a big run.

### Guardrail 1 — Spending limits (hard caps)

Under **Administration → Spending limits** you set a maximum dollar amount per QPU. When spend hits the cap, further tasks to that device are **rejected**. Because QPUs are Region-specific, so are spending limits: select the device's Region to see and set them.

![The Spending limits page with one limit: IQM Garnet, capped at $150.00, with $1.34 spent.](https://quantumdev.io/blog/media/image-cd1437054d84b5bc38bd18df161e11482f3e96ba-3432x1170-webp-960.webp)

**Create spending limit** opens a small form.

![The Create spending limit dialog: a device, a maximum amount in US dollars and an optional time period.](https://quantumdev.io/blog/media/image-27ca4e89332ac53f758f956ae21ff70133ff9271-1164x762-webp-960.webp)

### Guardrail 2 — In-code cost tracking

The SDK's `Tracker` (shown in [§6](#6-quantum-tasks-the-atomic-unit-of-work)) gives you a **near-real-time maximum cost estimate in USD** while your code runs. Wrap any run in `with Tracker() as tracker:` and call `tracker.qpu_tasks_cost()` / `tracker.simulator_tasks_cost()`. Every Braket example notebook already includes it.

### Guardrail 3 — Operational hygiene

- **Stop idle notebooks** (or enable the inactivity manager) — this is the most common surprise charge, and it's classical compute, not quantum.
- **Set a** `Maximum runtime` **stopping condition** on every hybrid job so a runaway optimizer can't loop forever.
- **Test on simulators first.** Local is free; on-demand SV1/DM1 are cheap. Only graduate to a QPU when the circuit is correct.
- **Tag** notebooks, tasks, and jobs so AWS Cost Explorer can slice spend by project.

> `Try it` — Before your very first QPU submission, set a $10 spending limit on that device. You'll run your experiment and physically cannot overspend. Raise it later when you trust your workflow.

## 11. Announcements: how to stay current

Because the fleet changes monthly, **Announcements** are very helpful. It's the changelog you actually need. It's where AWS posts new devices, retirements (with hard cutoff dates), and feature launches.

![The Announcements page: program sets on IonQ devices, the retirement of the TN1 simulator on 26 June 2026, and longer availability hours for AQT IBEX Q1.](https://quantumdev.io/blog/media/image-43b3a9b7779868bb376a3fcc377f9b42bc647a53-3428x1692-webp-960.webp)

> `Try it` — Skim Announcements once a month, or follow the AWS Quantum Computing Blog (linked from the dashboard's Community support widget). A retirement notice you missed is a broken pipeline you didn't see coming.

## 12. Your first hour on Braket: a hands-on path

Enough touring. Here's a concrete sequence that takes you from zero to "I ran on a real quantum computer," safely.

1. **Enable devices (2 min).** Administration → Permissions and settings → enable third-party devices; verify the three execution roles.
2. **Set a guardrail (1 min).** Administration → Spending limits → create a small cap (say $10) on one QPU you want to try.
3. **Browse the fleet (5 min).** Devices → open a simulator and a QPU; compare their Calibration tabs; copy a device ARN.
4. **Launch a notebook (5 min).** Notebooks → Standard → Create; enable the inactivity manager; open JupyterLab with the `conda_braket` kernel.
5. **Build + test for free (10 min).** Run the Bell-state circuit on `LocalSimulator()`, then on cloud `SV1`. Confirm the counts.
6. **Run on real hardware (10 min).** Change one line to a QPU ARN (mind the Region!), wrap it in `Tracker()`, submit, and watch the task move `QUEUED → RUNNING → COMPLETED`.
7. **Analyze (5 min).** Quantum tasks → open your task → **View in S3** for raw results; check `tracker.qpu_tasks_cost()`.
8. **Learn from the pros (rest of the hour).** Algorithm library → open Grover's or QAOA and modify it. Book a Braket office-hours slot.

## 13. Wrap-up: go press the buttons

The thing that surprises most developers about Amazon Braket is how straightforward the experience is. It's the same console muscle memory as any other AWS service: a left-nav, some wizards, IAM roles, an S3 bucket, a spending limit. The only difference is that the "compute" at the end of the pipe happens to be trapped ions in a vacuum chamber or neutral atoms held by lasers. You build and test for free, you flip one line to reach real hardware, and you can cap the cost so tightly that experimentation is genuinely low-risk.

So don't just read about it. Open the console, enable devices, set a $10 limit, and run a Bell state on a real QPU this week. The gap between "quantum computing is fascinating" and "I ran a quantum program" is about a few minutes and a handful of clicks.

Now you have the map.

Let's keep building.

This article was first published on [AWS Builder Center](https://builder.aws.com/content/3GaxVTZeaL9pWzjXj3k7tMynzbI/a-developers-field-guide-to-amazon-braket) on 17 July 2026.
