Florida Qiskit Fallfest Hackathon

0/12 done

For Participants

Participant Handbook — Florida Qiskit Fallfest Hackathon

This page renders the participant handbook in full. Summary pages link to its headings.

Florida Qiskit Fallfest Hackathon. Part of Qiskit Fall Fest 2026. Kickoff and challenge release: October 1, 2026. Local events: October 17–18, 2026. Local ceremony: October 18, 2026. First-place local winner deadline: October 31, 2026. Final: November 8, 2026. State championship ceremony: November 14, 2026.

0. The five-minute version

Here are two simple ways to prepare: create your IBM Quantum account and start thinking about a problem or topic that interests you. No prior quantum experience is required—we’ll guide you through the rest together.

Bring your curiosity. We’ll help with the qubits.

Essential pre-work is only what you need to access the event. The labels below keep a longer list from feeling like a test. Both pathways are full roles.

Builder/Developer Expert Domain/Industry Expert
Who Writes code during the event Frames problems, judges impact, tells the story
Pre-work time About 3–5 hours if you want a head start About 2–3 hours if you want a head start
Required before participating Your own IBM Quantum account (§4) Your own IBM Quantum account (§4.1). The API key can wait until you choose to code.
Recommended before the workshop Skim §2 and §3, and create a GitHub account (§6) Skim §2 and §3, create a GitHub account (§6), and read Domain/Industry Expert and Builder/Developer Expert
Optional next step A local install (§5.2) and a course from §7 Composer, the business course, and a draft canvas
We will complete this together Bell labs, the GitHub clinic, and the submission walk-through Problem framing, the canvas, and the story

Required before participating

  • Create your own IBM Quantum Platform account → §4. This is the account you will sign in with. There is no shared login.
  • Register and join a team on the registration page (opens in a new tab). Registration and teams are handled through DeepStation, campus by campus.

Recommended before the workshop

Optional next step

  • The courses and local install in §5 and §7
  • About 20 minutes in the Composer (opens in a new tab), dragging gates and watching the picture change

We will complete this together

  • The Bell labs, team formation, and opening the submission pull request

If you have about 30 minutes, the IBM Quantum account is the piece that lets you in. The recommended items make the first hour easier. We will cover the rest with you.

Registration

Registration and teams for the Florida Qiskit Fallfest Hackathon are handled through DeepStation, campus by campus. Open the registration page (opens in a new tab) to choose your campus, register, create a team, or join a team.

1. What Qiskit Fall Fest is

Qiskit Fall Fest is a worldwide, student-led series of quantum computing events run in partnership with IBM Quantum. Hosts on campuses and in communities around the world run their own hackathons, workshops, and challenges under one banner during the autumn.

The 2026 theme is "A decade of quantum on the cloud." The theme recognizes ten years since IBM placed its first quantum processor on the cloud. That shift is why a student can open a circuit from a browser. Keep it in mind when you decide how ambitious to be.

Florida Qiskit Fallfest Hackathon is the Florida event inside that global program.

Campuses: Miami Dade College, Florida Atlantic University, Embry-Riddle Aeronautical University, Florida Institute of Technology, and Florida Gulf Coast University. Capacity is up to 50 participants per campus.

The home page host directory is the card list: university, verified lead, confirmed venue, registration link when one is public, and a contact. Unconfirmed rooms say Details coming soon.

Official IBM announcement: https://www.ibm.com/quantum/blog/qiskit-fall-fest-2026 (opens in a new tab)

Qiskit-approved website: https://entangledsolutionsgroup.com/Qiskit-Fall-Fest-2026/ (opens in a new tab)

2. What you are actually going to build

Quantum advantage means demonstrating, through a fair comparison, that a quantum method outperforms the best relevant classical approach on a useful problem. You are not expected to prove that during a 48-hour hackathon. Your goal is to build a well-scoped project, create credible evidence, and explain honestly what the evidence does and does not show.

A mapped problem

The team begins with a real industry problem. Name the stakeholders and how the work is handled today. Write the variables, constraints, objectives, data, and success metrics. Map that problem to a QUBO, a Hamiltonian, a kernel, a circuit, or another quantum representation. When a small example is appropriate, run it on a simulator or on approved hardware. State the gap between that demo size and a meaningful real-world instance, and explain what would have to change in the hardware, the algorithms, the data, or the industry conditions. A Domain/Industry Expert or another subject-matter expert is especially valuable here.

Assess an optimization problem with the Next-Step Quantum Decision Guide (opens in a new tab)

Review the complete benchmarking sequence

A benchmark or comparison

Run the same bounded problem classically and with the quantum method. Use the same definition and comparable inputs. Define the metric before the run. Record the configurations, instance sizes, timing, quality, and resource use. You may explain where a future crossover might occur and what blocks it. Do not treat a crossover as something every project must find or predict. Report the result even when the classical approach stays ahead.

Build your benchmark plan

Open the benchmarking and readiness guide

An optimization comparison can continue in the Next-Step Quantum Decision Guide (opens in a new tab). Simulation, chemistry, classification, link prediction, and other non-optimization projects stay with the benchmarking sequence on this site.

A tool

A tool may be a circuit or state visualizer. It may translate a domain format into a QUBO, a Hamiltonian, a kernel, or a circuit. It may be a teaching aid, a workflow or benchmarking assistant, or a resource-estimation or evidence-tracking tool. Name the intended user, the input, the output, the value, and the limitations. A polished interface without a meaningful user problem is not enough.

An analysis

An analysis is a rigorous assessment of whether quantum computing fits a sector or a problem. Compare present classical methods with possible quantum approaches. Include a hardware and resource-gap assessment. Policy, risk, deployment, and readiness analysis belong here. A well-supported “not a fit yet” or “not quantum-shaped” conclusion is a complete project. Use credible sources, and verify technical claims against current hardware and algorithm capabilities.

Mapped-problem and analysis projects can be led primarily by Domain/Industry participants. Benchmark and tool projects generally require more Builder/Developer work. All four become stronger when someone understands what the output means in the real world.

Official statewide judging rubric

This is the official statewide judging rubric for the Florida Qiskit Fallfest Hackathon. Score each criterion 1–5. Weights convert scores to a total out of 100; hardware bonus adds up to +5.

Weighted Score = Σ (criterion score × weight) ÷ 5 × 100 → out of 100. Total = Weighted Score + Hardware Bonus (max 105).

Download the judging rubric workbook (opens in a new tab)

Criterion Weight What it measures
Problem Definition & Relevance 15% Is there a clear, meaningful problem? Does the team explain who it affects and why it matters?
Quantum Rationale & Understanding of Potential 20% Does the team understand WHY quantum might help here, and are they honest about today's limits (noise, qubit counts, no guaranteed speedup)?
Technical Implementation (Qiskit) 20% Does the code run? Is Qiskit used appropriately (circuits, primitives, transpilation, algorithms)? Judged relative to team experience.
Results & Validation 10% Are results shown and interpreted? Is there a comparison to a classical baseline, expected values, or simulator vs. hardware?
Innovation & Creativity 10% Is the idea or approach original, or a fresh take on a known problem?
Presentation & Communication 15% Can the team clearly articulate the problem, the solution and the results to both technical and non-technical audiences?
Q&A, Teamwork & Learning Journey 10% Can the team answer questions? Do all members contribute? Can they describe what they learned and next steps?
Total weight (must equal 100%) 100%

Problem Definition & Relevance (15%)

Is there a clear, meaningful problem? Does the team explain who it affects and why it matters?

1 – Beginning 2 – Developing 3 – Proficient 4 – Strong 5 – Exceptional
No clear problem; project is a demo without purpose. Problem named but vague; little sense of why it matters. Clear problem with some real-world context. Well-defined problem with clear stakeholders and motivation. Compelling, specific problem; scope is realistic and impact is clearly argued.

Questions judges can ask. What problem are you solving, and for whom? Why does it matter?

Quantum Rationale & Understanding of Potential (20%)

Does the team understand WHY quantum might help here, and are they honest about today's limits (noise, qubit counts, no guaranteed speedup)?

1 – Beginning 2 – Developing 3 – Proficient 4 – Strong 5 – Exceptional
No explanation of why quantum is used; or claims are inaccurate / overhyped. Generic claims ("quantum is faster") with little connection to the problem. Names a relevant quantum idea (superposition, entanglement, sampling, optimization, simulation) and links it to the problem. Clear reasoning for quantum fit; acknowledges current hardware limits and classical alternatives. Nuanced view of near-term vs. future potential; realistic about advantage; outlines what scale or hardware would be needed.

Questions judges can ask. Why quantum instead of a classical approach? What would need to improve for this to beat classical methods?

Technical Implementation (Qiskit) (20%)

Does the code run? Is Qiskit used appropriately (circuits, primitives, transpilation, algorithms)? Judged relative to team experience.

1 – Beginning 2 – Developing 3 – Proficient 4 – Strong 5 – Exceptional
Code missing or does not run. Runs partially; mostly copied tutorial code with little adaptation. Working implementation adapted to the problem; reasonable circuit design. Solid, well-structured code; thoughtful use of Qiskit features (e.g., primitives, transpiler, parameterized circuits). Polished, documented, reproducible; creative or advanced techniques used correctly (e.g., error mitigation, hybrid workflows).

Questions judges can ask. Walk me through your circuit. What did you build vs. reuse? What was hardest to get working?

Results & Validation (10%)

Are results shown and interpreted? Is there a comparison to a classical baseline, expected values, or simulator vs. hardware?

1 – Beginning 2 – Developing 3 – Proficient 4 – Strong 5 – Exceptional
No results shown. Results shown but not explained. Results explained with some interpretation. Results compared against a baseline or expectation; limitations discussed. Rigorous analysis: baselines, error bars or repeated runs, simulator vs. hardware comparison, clear conclusions.

Questions judges can ask. How do you know it worked? What did you compare against? What surprised you?

Innovation & Creativity (10%)

Is the idea or approach original, or a fresh take on a known problem?

1 – Beginning 2 – Developing 3 – Proficient 4 – Strong 5 – Exceptional
Direct copy of an existing tutorial or example. Minor variation on a common example. Some original thinking in problem choice or approach. Original idea or a creative application to a new domain. Highly original; would make other teams and judges say "I hadn't thought of that."

Questions judges can ask. What makes your approach different from existing examples?

Presentation & Communication (15%)

Can the team clearly articulate the problem, the solution and the results to both technical and non-technical audiences?

1 – Beginning 2 – Developing 3 – Proficient 4 – Strong 5 – Exceptional
Hard to follow; problem and solution unclear. Some structure, but heavy jargon or key pieces missing. Clear problem-solution story; mostly understandable to non-experts. Engaging and well-structured; good visuals; explains quantum concepts in plain language. Excellent storytelling; accessible to any audience while still technically accurate; within time.

Questions judges can ask. Can you explain your project in one sentence to someone with no physics background?

Q&A, Teamwork & Learning Journey (10%)

Can the team answer questions? Do all members contribute? Can they describe what they learned and next steps?

1 – Beginning 2 – Developing 3 – Proficient 4 – Strong 5 – Exceptional
Cannot answer basic questions about their own project. Answers are partial; one member carries the team. Answers most questions; describes some lessons learned. Confident, accurate answers; shared ownership; clear next steps. Insightful answers, strong collaboration, clear growth story and realistic roadmap.

Questions judges can ask. What did each of you contribute? What would you do with another month?

Hardware Bonus (judge selects one tier per team)

Hardware tier Bonus pts Description
Simulator only 0 Ran on a local or cloud simulator (e.g., Aer, statevector). No penalty; strong simulator projects can win.
Real quantum device 3 Circuit executed on real IBM Quantum hardware; job results shown.
Real device + noise analysis 5 Ran on real hardware AND compared to simulator, analysed noise, or applied error suppression/mitigation.

Scoring notes

  • Score relative to a student hackathon, not a research lab. A '3' is a solid, good project.
  • Simulator-only projects are fully eligible; the bonus rewards the extra effort of running on real hardware, it is not a requirement.
  • Reward honesty: a team that clearly explains why quantum may NOT yet beat classical methods shows more understanding than one that overclaims.

3. Two pathways, one team

Every team should include both perspectives. A builder-only team may create a clean implementation before confirming that the problem matters. A domain-only team may frame a strong opportunity without a testable experiment. The strongest projects come from combining the two.

Builder/Developer Expert. You may use Python and Qiskit. You may build, transpile, and run circuits on simulators and approved hardware. You may implement the quantum experiment, create or measure the classical baseline, and collect configurations, metrics, plots, and results. You may maintain reproducible notebooks and code, and document technical limitations. Python is expected. A physics degree is not required. At this level much of the work is linear algebra, structured problem mapping, and using APIs correctly.

Domain/Industry Expert. You may bring expertise from finance, logistics, energy, health, law, policy, agriculture, manufacturing, venture capital, operations, or another field. You may confirm that the problem exists, name the stakeholders and the business or community value, and describe how it is solved today. You may set the classical baseline and the meaningful metrics, and weigh feasibility, risk, policy, ethics, and deployment. You may judge whether the output matters, and lead USE-CASE.md, LIMITATIONS.md, the presentation, or the narrative. Coding is optional. You do not need to install Python. You may read notebooks without writing them.

Activity Domain/Industry Expert Builder/Developer Expert Shared
Select the problem Leads realism and relevance Checks technical tractability Yes
Define the baseline Explains the current method and meaningful metric Implements or measures it Yes
Form the quantum hypothesis Confirms why it would matter Defines how it can be tested Yes
Run the experiment Interprets the output Builds and executes it Review together
Document limitations Industry, policy, and deployment limits Technical and hardware limits Yes
Present and submit Leads or supports the story Demonstrates the implementation Yes

Read the pathways on this site: Two pathways. The long-form guide rendered there is Domain/Industry Expert and Builder/Developer Expert. A public note on the same idea is Domain track, Entangled Solutions Group (opens in a new tab).

If you are wondering whether you are “technical enough,” read the complete Domain/Industry guide before deciding not to participate. Your industry knowledge may be the part the team cannot replace with code.

4. Step one: IBM Quantum Platform account

Everyone does this. Both tracks. It takes about ten minutes and it's free.

Your IBM Quantum account is what gives you (a) access to real quantum computers, (b) the full IBM Quantum Learning course library with in-browser code, and (c) the Composer, a drag-and-drop circuit builder that requires no coding at all.

4.1 Create the account

  1. Go to https://quantum.cloud.ibm.com/registration (opens in a new tab)
  2. Sign up with an IBMid or a Google account. If you don't have an IBMid, the flow creates one for you.
  3. You'll land on the IBM Quantum Platform dashboard.

⚠️ Heads up on stale instructions. IBM Quantum Platform moved to IBM Cloud, and the old docs.quantum.ibm.com platform was retired on 1 July 2025. If you find a blog post, a YouTube video, or a Fall Fest guide from a previous year that tells you to go to quantum-computing.ibm.com, or shows code with channel="ibm_quantum", it is out of date and will not work. Use quantum.cloud.ibm.com and this handbook.

4.2 Create an instance

An instance is your allocation of quantum compute. Your account needs at least one.

  1. Go to https://quantum.cloud.ibm.com/instances (opens in a new tab)
  2. Create an instance on the Open Plan.
  3. Note that Open Plan instances can only be created in the us-east region. If your account switcher is set to eu-de, switch it.

4.3 Get your API key (Builder/Developer Expert only. The Domain/Industry Expert can skip to §6)

  1. From the dashboard at https://quantum.cloud.ibm.com/ (opens in a new tab), create your API key.
  2. Copy it immediately to a password manager. It is shown once and never again. It's a 44-character string.
  3. Also copy your instance's CRN (Cloud Resource Name) from the Instances page — hover over the CRN and click the copy icon.

Your API key is a credential. Do not paste it into a notebook you're going to commit to GitHub. Do not paste it in the event chat. §5.4 shows you how to store it properly. If you leak it, revoke it from the dashboard and make a new one.

4.4 Understand your quantum time budget

The Open Plan gives you up to 10 minutes of QPU execution time per rolling 28-day window, free. Track usage on the dashboard and on the Workloads page (opens in a new tab). The current limit is on the max execution time page (opens in a new tab). Simulators first.

The window is real, and it is usually enough for a small project. QPU time is measured in actual execution, and a typical small circuit run costs a couple of seconds. A loop left running on its own can use the window quickly. That is why we start on a simulator:

  • Develop against a simulator, and submit to hardware when the circuit is ready. (§5.5) This saves the limited QPU time for the run you mean to keep.
  • Check the queue before a late submission so you are not waiting on a busy machine.
  • One person per team can own hardware submissions. That keeps the window easy to track.

Full plan comparison: https://quantum.cloud.ibm.com/docs/en/guides/plans-overview (opens in a new tab)

5. Step two: get Qiskit running

Domain/Industry Expert: skip this entire section. Go to §6. You will not need Python. If you get curious later, come back. §5.1 needs no installation.

We recommend starting in the cloud. A local install is an optional next step when you want it. An older environment already on the machine can take longer than the lab itself, so the browser path keeps that time for the circuits.

Three options, in order of how much we recommend them:

IBM Quantum Learning (best starting point). The course lessons at https://quantum.cloud.ibm.com/learning (opens in a new tab) contain live code cells you run in the browser with your IBM Quantum account. Nothing to install, nothing to configure, and it's already wired to your account. Start with Use a quantum computer today (opens in a new tab).

IBM Quantum Composer (zero code at all). https://quantum.cloud.ibm.com/composer (opens in a new tab) — drag gates onto a circuit, watch the state visualizations update live, run it. This is a friendly way to see what a quantum circuit is. Recommended for both pathways.

Google Colab (for project work). Free hosted Jupyter. Start any notebook with:

!pip install qiskit qiskit-ibm-runtime matplotlib pylatexenc

Colab is the pragmatic choice for hackathon project work if you don't want to manage a local environment. Caveat: Colab sessions time out and lose state, so save to GitHub often, and don't hardcode your API key in a Colab notebook.

5.2 Path B: local install

Choose this if you want a persistent environment, you are working offline, or you prefer local tooling. It is an optional next step, not a requirement to attend.

Requirements: Python 3.10 or later. (Qiskit 2.5.x supports 3.10 through 3.14.) 64-bit OS. Qiskit 2.x dropped 32-bit support entirely.

macOS / Linux:

# 1. Make a project folder and a virtual environment
mkdir fallfest && cd fallfest
python3 -m venv .venv
source .venv/bin/activate

# 2. Install everything in ONE pip command
pip install qiskit qiskit-ibm-runtime jupyter matplotlib pylatexenc numpy

Windows (PowerShell):

mkdir fallfest; cd fallfest
python -m venv .venv
.venv\Scripts\Activate.ps1

pip install qiskit qiskit-ibm-runtime jupyter matplotlib pylatexenc numpy

Windows users on Git Bash: activate with source .venv/scripts/activate instead.

Why these packages:

Package What it's for
qiskit The SDK itself: circuits, operators, transpiler, local simulators
qiskit-ibm-runtime Talks to IBM's real quantum computers. Separate package. Install it when a notebook will use hardware. The Bell lab does not need it.
jupyter Notebooks
matplotlib + pylatexenc Circuit diagrams and plots. Without pylatexenc, circuit.draw('mpl') cannot draw the picture. The counts can still print.

Habits that keep a local install smooth:

  1. Use a virtual environment. A shared global Python often mixes package versions, and that mix is a common reason an import fails later. A fresh environment avoids that.
  2. Install everything in a single pip install command. Separate installs can resolve to a set of versions that looks fine and then breaks a later import.
  3. If you have an old Qiskit 0.x installation, make a fresh virtual environment instead of upgrading it in place. Qiskit 1.0 changed the packaging, and in-place upgrades from 0.x often fail in ways that are hard to untangle. You can keep learning in the browser while a local environment is in progress.

Official install guide: https://quantum.cloud.ibm.com/docs/en/guides/install-qiskit (opens in a new tab)

5.3 Verify your install

Save this as check_setup.py and run it. It uses only the local simulator. No account needed, no QPU time consumed.

"""Fall Fest environment check. Run: python check_setup.py"""
import sys

print(f"Python: {sys.version.split()[0]}")

import qiskit
print(f"Qiskit: {qiskit.__version__}")

try:
    import qiskit_ibm_runtime
    print(f"Runtime client: {qiskit_ibm_runtime.__version__}")
except ImportError:
    print("Runtime client: NOT INSTALLED  <-- run: pip install qiskit-ibm-runtime")

# Build a Bell state: two qubits, maximally entangled.
from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler

qc = QuantumCircuit(2)
qc.h(0)          # put qubit 0 into superposition
qc.cx(0, 1)      # entangle qubit 1 with qubit 0
qc.measure_all()

result = StatevectorSampler().run([qc], shots=1000).result()
counts = result[0].data.meas.get_counts()

print(f"Bell state counts: {counts}")
print("\nExpect roughly 500 '00' and 500 '11', and essentially no '01' or '10'.")
print("Those two outcomes being correlated and the other two being absent")
print("matches this Bell preparation. A histogram alone is not a complete proof of entanglement.")

If that prints something like {'00': 496, '11': 504}, you are done. Go to §6.

5.4 Connect to real hardware (Builder/Developer Expert)

Once, in a trusted environment (your own laptop, not a shared lab machine, not Colab):

from qiskit_ibm_runtime import QiskitRuntimeService

QiskitRuntimeService.save_account(
    token="<your-44-character-API-key>",
    instance="<your-instance-CRN>",
    region="us-east",
    set_as_default=True,
)

This writes your credentials to a local config file. After that, a notebook on that trusted computer can do:

from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()          # loads saved credentials
backend = service.least_busy(operational=True, simulator=False)
print(f"Using: {backend.name}")

On a shared or untrusted machine, don't save the account — pass the token explicitly each session, or follow the untrusted environment guide (opens in a new tab).

The default channel is ibm_quantum_platform and you almost never need to specify it. Full detail: https://quantum.cloud.ibm.com/docs/en/guides/initialize-account (opens in a new tab)

5.5 The one workflow rule

Iterate on a simulator. Submit to hardware once.

The local check in §5.3 uses StatevectorSampler on your computer. It does not spend Open Plan time and it does not need an API key. Do not start on a QPU.

from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
counts = StatevectorSampler().run([qc], shots=1000).result()[0].data.meas.get_counts()

Do not use channel="ibm_quantum", IBMQ.load_account(), execute(), or qiskit.Aer. Those calls belong to older tutorials.

A hardware run is optional, and only after the circuit is final. It spends the Open Plan window of 10 minutes per 28-day rolling window. Noise on hardware can add counts on 01 and 10. That is not a reason to skip the simulator.

IBM’s hello-world guide shows the same four-step pattern, and then a much larger circuit: https://quantum.cloud.ibm.com/docs/en/guides/hello-world (opens in a new tab). This event does not assign that larger circuit. The Bell lab uses a sampler because it needs counts.

6. Step three: GitHub

Everyone does this. Both pathways. A Domain/Industry Expert will use GitHub to read the challenge briefs, file issues, and contribute written work. Market analysis, use-case documents, and slides live in the repo alongside code.

6.1 Create an account

  1. Go to https://github.com/signup (opens in a new tab)
  2. Pick a username you would be comfortable putting on a résumé. Teammates and reviewers may see it.
  3. Verify your email address. GitHub waits on that verification before several actions.
  4. Turn on two-factor authentication, at https://github.com/settings/security (opens in a new tab). GitHub asks many contributors for it. Setting it up now, and saving the recovery codes somewhere you can find, keeps later steps from pausing. An authenticator app works well.
  5. Add a display name and a one-line bio. Judges and recruiters look at these.

Students: the GitHub Student Developer Pack (opens in a new tab) is free with a .edu address and includes Copilot and other tools. Approval can take a few days, so it is a comfortable thing to request before the workshop if you want it. It is optional.

6.2 Join the event repository

The project repository is private. Ask to join it. An organizer adds your GitHub account.

  1. Create a GitHub account if you do not have one.
  2. Ask to join https://github.com/robertloredo/FAU-Qiskit-Fallfest-2026 (opens in a new tab). Send your GitHub username in the event chat, or tell your local host. Do not send a password or an API key. A GitHub username is enough.
  3. When you can open the repository, star it if you want GitHub notifications.
  4. This website is the guide. Your team’s project goes in the private repository above.

6.3 Repository layout

After you can open the repository, the project folders look like this:

FAU-Qiskit-Fallfest-2026/
├── README.md
├── challenges/                ← Coming soon, with the October 1 challenge release
└── submissions/
    ├── _TEMPLATE/             ← copy this
    └── team-<yourname>/       ← your team's folder

6.4 How to submit

Teams work on a branch in the private project repository, then open a pull request. Ask to join the repository first. If this is new, the day-one GitHub clinic is for you. It takes about fifteen minutes, and we would rather walk through it together than leave you to discover it late.

# After you can open the private repository
git clone https://github.com/robertloredo/FAU-Qiskit-Fallfest-2026.git
cd FAU-Qiskit-Fallfest-2026

# Start your team's work
git checkout -b team-<yourteamname>
cp -r submissions/_TEMPLATE submissions/team-<yourteamname>

# As you work
git add submissions/team-<yourteamname>
git commit -m "Add problem framing and initial circuit"
git push -u origin team-<yourteamname>

Then open a Pull Request on GitHub against main, titled [SUBMISSION] Team <name> — <project title>.

Prefer clicking to typing? GitHub Desktop (opens in a new tab) does all of the above with buttons. Or edit files directly in the browser on github.com — for written deliverables that's often the fastest path, and it's a completely legitimate way to contribute.

Please open the pull request by October 31, 2026 so judging can review every eligible submission fairly. That date is the first-place local winner packet. Pull requests opened after the deadline published with the challenge are not judged. You can keep pushing to a pull request that is already open. Opening it early leaves room to fix small issues together.

6.5 What goes in your submission folder

File Required? Who typically writes it
README.md ✅ Domain + Builder together
Notebook(s) or source ✅ Builder
USE-CASE.md — the problem, the industry, why it matters, what it'd take to be real ✅ Domain
requirements.txt ✅ if code Builder
Slides / demo video ✅ Domain
LIMITATIONS.md — what you didn't solve and why Strongly encouraged Whole team

That LIMITATIONS.md is part of the story. A team that clearly states what its approach cannot do gives reviewers something they can trust.

New to git? https://docs.github.com/en/get-started (opens in a new tab)

7. Quantum learning resources

Choose one lane and a time budget you can enjoy. The other courses can wait until after the event. They are an optional next step, not a test you have to finish first.

If you are the Domain/Industry Expert (2–3 hours)

Resource Time Why
Quantum business foundations (opens in a new tab) 3h Built for exactly this audience. Ends in an exam and a Credly digital badge you can put on LinkedIn. Start here.
Designing and leading quantum projects (opens in a new tab) 4h For anyone who may sponsor or govern one of these.
IBM Quantum Composer (opens in a new tab) 20 min Play. Drag gates. No coding. Best intuition-per-minute available.
Domain/Industry Expert and Builder/Developer Expert 30 min Our own guide — roles, industry prompts, and the use-case canvas you'll fill in on day one.

If you are the Builder/Developer Expert (3–5 hours)

Resource Time Why
Use a quantum computer today (opens in a new tab) 5h The fastest on-ramp. IBM's own framing: you don't need a physics degree or years of programming experience — if you can follow along with a notebook and click "Run," you're ready. Start here.
Basics of quantum information (opens in a new tab) 15h John Watrous's course. The real foundation. Do the first two lessons before the event; finish it after.
Quantum computing in practice (opens in a new tab) 8h 100+ qubit workloads and what actually works on today's hardware.
Hello world guide (opens in a new tab) 30 min Your first circuit on real hardware, end to end.

If you're going deep on a specific application

Course Time For
Variational algorithm design (opens in a new tab) 8h Optimization projects — the workhorse pattern
Quantum machine learning (opens in a new tab) 10h Classification, kernels, feature maps
Quantum chemistry with VQE (opens in a new tab) 5h Molecules, materials, drug discovery
Quantum diagonalization algorithms (opens in a new tab) 10h VQE, Krylov, and the current state of the art
Integrating quantum and HPC (opens in a new tab) 6h Hybrid workflows, realistic deployment

Full catalog: https://quantum.cloud.ibm.com/learning/en/courses (opens in a new tab)

Notebooks

We've annotated the useful ones, including which are readable without running anything — in NOTEBOOK-CATALOG.md. Domain/Industry Expert: that document was written for you.

8. Event schedule

Times, speaker names, and any room that is not listed here are TBA.

Date What Where
October 1, 2026 Kickoff and challenge release TBA
October 17–18, 2026 Local events Miami Dade College Wolfson Campus, AI Center, Building 2, Room 2104. Other campus rooms are TBA. Embry-Riddle Aeronautical University: November 7–8, 2026.
October 18, 2026 Local ceremony Campus venues are listed with the local events.
October 31, 2026 First-place local winner deadline Packet to the hosts
November 8, 2026 Final Venue TBA
November 14, 2026 State championship ceremony Venue TBA

Capacity is up to 50 participants per campus. A setup clinic and a GitHub clinic may run inside the local events. Whether they do is TBA.

9. Troubleshooting

Unexpected results are a normal part of this work. Each note below says what may have happened, one or two things to try, where to get help, and how you can keep learning while it is resolved.

ModuleNotFoundError: No module named 'qiskit', even after an install. What may have happened: the notebook kernel is a different Python than the one where Qiskit was installed. Try this: activate the virtual environment, then start Jupyter from that same shell. In Anaconda Navigator, use the "Applications on" dropdown to select that environment before launching. Help: https://discord.gg/vz6uTbtJzR (opens in a new tab) or your local university lead. Composer in the browser does not need this kernel, so you can keep building the Bell circuit there.

ImportError mentioning qiskit-terra or "invalid environment". What may have happened: Qiskit 0.x and a current Qiskit are installed in the same environment. Try this: create a fresh virtual environment and install once. An in-place upgrade from 0.x usually will not sort this out. Help: Discord. The browser path in §5.1 lets you keep learning while the new environment is created.

Circuit drawing fails or looks unexpected. What may have happened: pylatexenc or matplotlib is missing. Try this: pip install pylatexenc matplotlib, then restart the kernel. Help: Discord if the picture still does not appear. The printed counts are enough to continue the lab.

401 Unauthorized when connecting to the service. What may have happened: the API key does not match, or a bearer token was used where the API key belongs. Try this: create a new key at https://quantum.cloud.ibm.com/ (opens in a new tab) and run save_account again on a trusted computer. If the old key was visible on a shared screen, revoke it. Help: your local university lead. Do not paste the key into chat. The Bell lab on the local simulator does not need this connection, so you can keep going there.

"No instance found" or the QPU list is empty. What may have happened: the region switcher is not us-east. Open Plan instances are created in that region. Try this: switch the region in the dashboard header, then look again. Help: the account page on this site, then a workshop facilitator. Composer and the local simulator still work while the region is sorted out.

Compilation errors during pip install. What may have happened: this Python has no prebuilt wheel. Qiskit expects 64-bit Python 3.10 or later. Try this: confirm that version, then ask in https://discord.gg/vz6uTbtJzR (opens in a new tab) before installing extra compilers. Help: Discord. §5.1 runs in the browser while the install is resolved.

A job stays in the queue. What may have happened: the shared fair-share queue is busy. That is normal at peak times. Try this: service.least_busy(operational=True, simulator=False), and check https://quantum.cloud.ibm.com/computers (opens in a new tab). Help: Discord if it stays queued much longer than the computers page suggests. Keep working on the local simulator in the meantime.

Code from an older tutorial does not run. What may have happened: the tutorial uses channel="ibm_quantum", IBMQ.load_account(), execute(), or qiskit.Aer. Those calls belong to an older API. Try this: compare it with the note in §4.1 and use the current calls in §5. Help: Discord, with the error text. Do not paste an API key, a CRN, or a password. The examples in this handbook are a fine place to keep learning.

Still stuck: https://discord.gg/vz6uTbtJzR (opens in a new tab), or your local university lead, then Kevin Robinson at kevin@quantumglobalgroup.io. Share the error text so we can see what happened. Do not paste an API key, a CRN, or a password. You can keep learning on the simulator or in Composer while someone helps.

10. Support and community

Code of conduct: Coming soon. Until it is published, write to any co-lead: your local university lead, then Kevin Robinson at kevin@quantumglobalgroup.io.

11. Accessibility, hardware, and cost

  • No laptop? Loaner laptops are not confirmed. Email any co-lead before you travel: your local university lead, then Kevin Robinson at kevin@quantumglobalgroup.io. Do not assume a machine will be waiting.
  • Weak laptop? Everything in §5.1 runs in a browser. A Chromebook is sufficient.
  • Nothing here costs money. Qiskit is open source (Apache 2.0). The IBM Quantum Open Plan is free. GitHub is free. If someone asks you to pay for something to participate, that's not part of this event.
  • Accessibility needs: contact any co-lead in advance: your local university lead, then Kevin Robinson at kevin@quantumglobalgroup.io.

12. Final Step: Study Hetionet and Build Your Project Framework

Hetionet is an advanced completed example, not the minimum level for this hackathon. Study it on the Hetionet example page, then build your own framework. Do not copy the project.

The sequence is Problem → Team roles → Data → Classical baseline → Quantum component → Benchmark → Evidence → Limitations → Demo → Submission. Each stage connects to a question for your own project.

Hetionet is classification and link prediction, not an optimization problem. Do not send it through the optimization-only decision guide. The comparison does not show quantum advantage, and it is not a clinical result.

On the verified primary configuration, hybrid stacking PR-AUC is 0.7987, Random Forest is 0.7838, and Extra Trees is 0.7807. If 0.8581 appears, the quantum kernel was cached while the classical components were tuned with Optuna.

Public files, through the project’s own links: README (opens in a new tab), paper (opens in a new tab), evidence (opens in a new tab), notebooks (opens in a new tab), glossary (opens in a new tab), and demo (opens in a new tab). The other notebooks are the classical baseline (opens in a new tab), quantum training (opens in a new tab), and testing (opens in a new tab).

Stage Hetionet example Question for your team
Problem Compound-treats-Disease link prediction What precise problem are we solving?
Current method Classical link-prediction models How is it solved today?
Baseline Random Forest and Extra Trees What must our experiment be compared against?
Quantum hypothesis A quantum kernel may add a useful signal in a hybrid stack What bounded quantum contribution are we testing?
Experiment Four-notebook pipeline What small experiment can we finish?
Metric PR-AUC What number will determine the result?
Evidence README, results files, configurations, and notebooks What files will allow someone to verify our claim?
Limitations No standalone quantum advantage and no clinical result What does our result not prove?
Recommendation Continue researching the hybrid approach honestly Continue, narrow, pause, or stop?
Submission Documentation, notebooks, evidence, presentation, and demo Is our project reproducible and understandable?

Use the Hetionet framework as a checklist for your own project. Keep the structure, replace the problem, establish your own baseline, choose an appropriate quantum hypothesis, and document the evidence and limitations.

Appendix A: Glossary for the Domain/Industry Expert

You'll hear these on day one. You don't need to be able to derive any of them.

Term What it means when someone says it at this event
Qubit The quantum unit of information. Unlike a bit, it can be in a combination of 0 and 1 until measured.
Superposition That "combination of states" property. It's not "both at once" in any useful everyday sense, it's a weighted combination that produces probabilities on measurement.
Entanglement Two or more qubits whose outcomes are correlated in ways no classical system can reproduce. It's the resource that makes quantum computing different.
Circuit A quantum program. A sequence of operations (gates) on qubits.
Gate One operation on one or more qubits. The building block.
Shots How many times you run a circuit. Quantum results are probabilistic, so you run repeatedly and read the distribution.
QPU Quantum Processing Unit: the actual quantum chip.
Transpile Rewriting your circuit into the specific gates and connectivity a given QPU physically supports.
Noise Real quantum hardware makes errors. Managing this is most of the engineering.
Error mitigation Statistical techniques to recover a good answer from noisy runs. Different from error correction, which is a future, much bigger thing.
QUBO Quadratic Unconstrained Binary Optimization: a standard way of writing an optimization problem that quantum optimizers can consume. If your problem can become a QUBO, it's in scope.
Hamiltonian A mathematical description of a system's energy. Chemistry and physics problems are usually posed this way.
VQE / QAOA The two most common hybrid quantum-classical algorithms. VQE for finding lowest-energy states; QAOA for optimization.
Utility scale Circuits large enough that classical brute-force simulation gets hard — roughly 100+ qubits. Where the interesting current research lives.

Appendix B: Pre-event checklist

Use the labels. You do not need every box ticked before you walk in.

Required before participating

  • Registered and joined a team from the registration page (opens in a new tab). Registration and teams are handled through DeepStation, campus by campus.
  • Created my own IBM Quantum Platform account (§4.1). I am the only person who knows the password.
  • Open Plan instance created in us-east (§4.2), when the account flow offers it. The Bell lab can start on the simulator if this is still open.

Recommended before the workshop

Optional next step

  • Spent about 20 minutes in the Composer (opens in a new tab), dragging gates and watching the picture change
  • API key and CRN saved privately, for a later hardware run. I can revoke the key and create a replacement if it is exposed.
  • Builder/Developer Expert: Python 3.10+ available, and Qiskit installed in a virtual environment (§5.2)
  • Builder/Developer Expert: check_setup.py runs and shows a Bell state (§5.3)
  • Builder/Developer Expert: save_account() run on a trusted computer, and QiskitRuntimeService() connects (§5.4)
  • Builder/Developer Expert: one circuit on hardware via the hello world guide (opens in a new tab), after the simulator run looks right
  • Builder/Developer Expert: started Use a quantum computer today (opens in a new tab)
  • Domain/Industry Expert: Quantum business foundations (opens in a new tab), including the badge if you want it
  • Domain/Industry Expert: skimmed two domain notebooks from NOTEBOOK-CATALOG.md

We will complete this together

  • Bell labs in Composer and in Python
  • Team formation and a problem we can say out loud
  • The submission pull request, including limitations

If a step in this handbook is broken or out of date, open an issue. Links change when IBM ships updates, and the person who finds a broken step helps the next participant.