Skip to content
BranchesTags

Repository files navigation

Project Q: 30 Days Challenge — From Zero to Quantum Hero

IBM Quantum Python Version Qiskit SDK License

A structured 30-day engineering journey documenting the progression from quantum computing fundamentals to enterprise-grade quantum software development.

This repository serves as a central portfolio hub detailing daily workbooks, learning workbooks, practical implementations, mini-projects, engineering logs, and production-ready packages developed throughout the challenge.

About | Timeline | Featured Projects | Comparison Table | Structure | Learning Outcomes | Tech Stack | Achievements | Screenshots | Onboarding Guide

Table of Contents

  1. About the Challenge
  2. Journey Timeline
  3. Featured Projects
  4. Project Comparison Table
  5. Repository Structure
  6. Learning Outcomes
  7. Technology Stack
  8. Achievements Dashboard
  9. Screenshots
  10. How to Explore This Repository
  11. Future Roadmap
  12. Resources
  13. Contributing
  14. License
  15. Acknowledgements
  16. Footer

About the Challenge

Project Q was started as an intensive 30-day sprint designed to bridge the gap between abstract quantum physics theory and practical software engineering. By applying an engineering-first mindset, the challenge progresses from basic single-qubit manipulations to building full-stack platforms and production-grade cryptographic frameworks.

Objectives

  1. Master Core Quantum Mechanics: Build mathematical and programming intuition around superposition, entanglement, interference, and measurement collapse.
  2. Develop Practical Quantum Systems: Leverage Qiskit and Qiskit Aer to build, transpile, and execute quantum circuits on local statevector simulators and physical remote hardware.
  3. Bridge Quantum and Classical Tech Stacks: Integrate quantum backends with modern web architectures (FastAPI, Next.js, SQLite, Matplotlib).
  4. Learn Production Standards: Maintain rigorous test coverage, clean folder structures, detailed documentation, and robust CI/CD pipelines.

Journey Timeline

Below is the chronological roadmap of the challenge, tracking skill acquisition across the four weeks of work:

┌─────────────────────────────────────────────────────────────────────────┐
│ WEEK 1: QUANTUM FUNDAMENTALS                                            │
│ • State Vectors, Superposition, and Bloch Sphere representations       │
│ • Unitary Operators, Hadamard, Pauli, and Phase shifting gates          │
│ • Entanglement creation using CNOT and Bell states configurations       │
└────────────────────────────────────┬────────────────────────────────────┘
                                     │
                                     ▼
┌─────────────────────────────────────────────────────────────────────────┐
│ WEEK 2: QISKIT PROGRAMMING & WEB INTERFACES                             │
│ • Quantum measurement statistics extraction and matplotlib plotting     │
│ • Quantum Random Number Generation (QRNG) and seed entropy mappings     │
│ • FastAPI integration for quantum state tracking and job execution      │
└────────────────────────────────────┬────────────────────────────────────┘
                                     │
                                     ▼
┌─────────────────────────────────────────────────────────────────────────┐
│ WEEK 3: QUANTUM ALGORITHMS & HARDWARE                                   │
│ • Grover's Search and Deutsch-Jozsa oracle circuit implementations     │
│ • Quantum Fourier Transform (QFT) and Quantum Teleportation protocols   │
│ • Remote QPU executions using the IBM Quantum Runtime Service           │
└────────────────────────────────────┬────────────────────────────────────┘
                                     │
                                     ▼
┌─────────────────────────────────────────────────────────────────────────┐
│ WEEK 4: ENTERPRISE QUANTUM DEVELOPMENT (QST FRAMEWORK)                  │
│ • Flagship Mini-Project: Quantum Security Toolkit (QST)                 │
│ • Cascade Error Correction (Phase 13A) multi-pass parity reconciler     │
│ • 2-universal Toeplitz Privacy Amplification (Phase 13B) compression    │
│ • Production release engineering (v1.0.0), type annotations, and CI/CD │
└─────────────────────────────────────────────────────────────────────────┘

Featured Projects

Mini Project 1 — Quantum Randomness Laboratory

  • Folder Link: ./Mini_Project_1/Quantum-Randomness-Lab
  • Status: Completed | Difficulty: Beginner | Est. Time: 10 hours
  • Current Version: 1.0.0
  • Short Description:
    A research-oriented laboratory exploring quantum superposition collapse to generate true randomness, contrasting with classical pseudorandom algorithms. Features a Quantum-Secured Password Generator that maps quantum outputs to standard character arrays.
  • Key Features:
    • 1-qubit QRNG sequence generator with console telemetry.
    • Matplotlib histograms plotting raw randomness distribution.
    • Statistical calculations checking sequence mean and standard deviations.
    • Superposition mapping character translation engine generating 16-character passwords.
  • Technology Stack: Python, Qiskit, Qiskit Aer, NumPy, Matplotlib.
  • Lessons Learned:
    Learned how quantum measurement collapses act as a physical entropy source, and understood the mathematical differences between pseudo-random distributions and true quantum probabilities.

Mini Project 2 — Quantum Platform Enterprise Dashboard

  • Folder Link: ./Mini_Project_2/quantum-platform-enterprise
  • Status: Completed | Difficulty: Intermediate | Est. Time: 25 hours
  • Current Version: 1.0.0
  • Short Description:
    A full-stack, enterprise-grade quantum circuit execution and hardware telemetry platform. Researchers can design circuits, dispatch them to FastAPI execution pipelines, and monitor simulated node queue loads and CPU temperatures.
  • Key Features:
    • FastAPI Backend: Orchestrates SQLite asynchronous database operations and manages circuit state machines (Draft ➔ Queued ➔ Running ➔ Completed).
    • Next.js frontend: Provides a rich telemetry dashboard featuring real-time sparkline visualizers.
    • Qiskit Drawing Integration: Automatic color-coded quantum circuit drawing exports (PNG format).
  • Technology Stack: Next.js 14, Tailwind CSS, FastAPI, SQLite, SQLAlchemy, Qiskit, Matplotlib.
  • Lessons Learned:
    Mastered asynchronous task routing in FastAPI and managed database transactions to sync classical frontend UI states with background quantum simulation runners.

Mini Project 3 (Flagship) — Quantum Security Toolkit (QST)

  • Folder Link: ./Mini_Project_3/Quantum Security Toolkit (QST)
  • Status: Completed | Difficulty: Advanced | Est. Time: 45 hours
  • Release: GitHub Release | Current Version: 1.0.0
  • Short Description:
    A modular, research-oriented quantum security framework implementing end-to-end BB84 Quantum Key Distribution (QKD), active eavesdropping interception simulations, post-sifting Cascade parity error correction, and 2-universal privacy amplification (Toeplitz and Carter-Wegman affine matrix over $\text{GF}(2)$).
  • Key Features:
    • BB84 Core Engine: Models polarization basis reconciliations ($Z$ & $X$), basis sifting, and Quantum Bit Error Rate (QBER) estimates.
    • Adaptive Execution: Clifford stabilizer routing enabling simulation of up to 2,048 qubits in ~4 seconds, with remote IBM Quantum Runtime execution and automatic Aer fallback.
    • Cascade Error Correction: Multi-pass recursive parity reconciliation using iterative binary search bit-error localization.
    • 2-Universal Privacy Amplification: Strongly 2-universal hash family (Toeplitz + Carter-Wegman affine matrix over $\text{GF}(2)$) compressing keys and calculating Min-Entropy ($H_{\infty}$) and trace distance security bounds.
    • Enterprise Security Defenses: Atomic file writes (mkstemp + os.fsync + os.replace), path traversal protection (QST-VAL-405), and RAM ceiling estimators.
    • Release Quality Assurance: Fully type annotated, checked by strict linting rules, and verified by 229 automated tests (97% code coverage, Ruff clean, strict Mypy clean).
  • Technology Stack: Qiskit, Qiskit Aer, NumPy, pytest, pytest-cov, Matplotlib, black, ruff, mypy.
  • Lessons Learned:
    Implemented complex post-processing cryptography algorithms, decoupled calculators using service-oriented patterns, eliminated canvas memory leaks, and locked public interfaces under strict SemVer compatibility bounds for production environments.

Project Comparison

Project Category Language Framework Difficulty Status Documentation Automated Tests
Quantum Randomness Lab Scientific Core Python Qiskit Beginner Complete README None (Manual)
Platform Enterprise Full-Stack Dashboard JS / Python Next.js / FastAPI Intermediate Complete Docs Folder Backend checks
Security Toolkit (QST) Flagship Cryptography Python Qiskit / Pytest Advanced Complete Docs Folder 229 Passed (97% Cov)

Repository Structure

Project-Q-30-Days-Challenge/
├── .github/                  # PR templates, dependabot, and workflow templates
├── assets/                   # Shared image resources and terminal snapshots
├── Day_01 to Day_20/         # Daily learning workbooks and solved notes
│   ├── Solutions_and_Notes/  # Personal study logs and handwritten summaries
│   └── solved_workbooks/     # Solved Jupyter worksheets
├── Mini_Project_1/           # Quantum Randomness Lab and password generator
├── Mini_Project_2/           # Full-Stack Quantum Computing Management Dashboard
├── Mini_Project_3/           # Flagship: Quantum Security Toolkit (QST) python package
└── README.md                 # Challenge portfolio landing page

Learning Outcomes

  • Quantum Computing: Mastered qubit polarization, quantum state vectors, Bloch sphere representation, and Oracle quantum computation models (Grover, Deutsch-Jozsa).
  • Quantum Cryptography: Implemented BB84 QKD, modeled eavesdropping collapse vectors, and calculated trace distance security limits.
  • Post-Processing Protocols: Coded recursive Cascade parity correction loops and universal Toeplitz compression matrices.
  • Systems Architecture: Applied SOLID patterns, dependency inversion backends, and modular calculations services.
  • Full-Stack Development: Engineered responsive Next.js dashboards and asynchronous FastAPI SQLite state machines.
  • QA & Engineering: Enforced 97% pytest coverage, strict static typing (mypy), and automated GitHub Actions workflows (build, lint, CodeQL scans).

Technology Stack

Layer Technology Purpose
Programming Languages Python 3.11, JavaScript (TypeScript) Core simulation scripts and web dashboard interface
Quantum Frameworks Qiskit SDK, Qiskit Aer Circuit building, transpilation, and local statevector simulators
Execution Platforms IBM Quantum Runtime Service Remote physical QPU hardware executions
Web Technologies Next.js 14, FastAPI, Tailwind CSS, Vercel Telemetry frontend UI and jobs execution backend API
Database Systems SQLite, Async SQLAlchemy Asynchronous database operations and circuit jobs logging
Testing & Quality pytest, pytest-cov, mypy, black, ruff Automated tests, coverage calculations, formatting, and linting
Visualizations Matplotlib, Framer Motion Scientific plots exports (PNG/SVG/PDF) and animated graphs

Achievements Dashboard

  • 30 Learning Days: Completed daily worksheets mapping quantum fundamentals.
  • 3 Major Projects: Designed, implemented, and delivered three distinct repositories.
  • 229 Automated Tests: Maintained 97% aggregate coverage on the flagship cryptography framework.
  • IBM QPU Integration: Successful remote circuit executions and noise-aware simulators routing.
  • Complete Documentation: Over 40 distinct architectural ADRs and user guides written.
  • Clean Code: Zero TODO/FIXME tags or debug logs remaining in production packages.

Screenshots

Mini Project 1: Histogram Outputs

True quantum randomness distribution generated from qubit superposition collapses:

QRNG Histogram

Mini Project 2: Enterprise Dashboard Overview

Real-time quantum platform dashboard tracking nodes telemetry, queue load, and temperatures:

Enterprise Dashboard

Mini Project 3: Flagship QST Simulation Sweep

Scientific plot illustrating QBER vs. Interception Probability trend analysis:

QST Plot

How to Explore This Repository

We recommend recruiters and hiring managers explore the challenge in this order (Approx. 10 minutes):

[Start Here: Root README]
       │
       ▼
[Review Daily Notes (e.g. Day_01 to Day_20)]
       │
       ▼
[Run Mini Project 1 (Randomness Lab)] ---> cd Mini_Project_1/Quantum-Randomness-Lab && python quantum_password.py
       │
       ▼
[Explore Mini Project 2 (Dashboard)]  ---> Navigate to Live Demo: quantum-enterprise.vercel.app
       │
       ▼
[Audit Flagship Mini Project 3 (QST)] ---> cd Mini_Project_3/Quantum\ Security\ Toolkit\ (QST) && python examples/06_complete_pipeline.py

Future Roadmap

  • LDPC Error Correction: Integrate Low-Density Parity-Check algorithms into QST.
  • Entanglement Protocols: Implement E91 simulation scripts.
  • Multi-Node Quantum Repeaters: Support multi-hop quantum repeaters simulation models.
  • Portfolio Deployments: Host the FastAPI platform backend on Render/AWS.

Resources

🤝 Contributing & Feedback

Contributions, suggestions, and feedback are highly welcome!

  • Got suggestions or feature requests? Feel free to open a new Issue or share your ideas.
  • Want to contribute? Feel free to fork this repository, make your changes, and submit a Pull Request.

⭐ Show Your Support

                   Love this tool? Help us grow:
✨ Star the repository   (GitHub Star Button)
🐛 Report bugs          (GitHub Issues)
💡 Suggest features     (GitHub Discussions)
📢 Share with others    (LinkedIn/Twitter)
🤝 Contribute code      (Pull Requests)

License

This repository is licensed under the MIT License - see the LICENSE file for details.

Acknowledgements

  • The organizers and authors of the Project-Q 30-Day challenge.
  • The open-source teams maintaining Qiskit, FastAPI, Next.js, and Matplotlib.

👤 Author & Contact

👨‍💼 Shlok Thorat
Let's connect on LinkedIn, collaborate, and build amazing things together!

Email GitHub LinkedIn

Made with Shlok! for Quantum Computing Innovation • Back to Top

About

A 30-day intensive journey into Quantum Computing and Qiskit. This repository contains my daily workbooks, learning notes, and practical implementations, including a Quantum-Secured Password Generator built as a mini-project

project-q-30-days-challenge.vercel.app

Topics

30dayscchallengeibmibm-quantumproject-qpythonqiskitqrngquantumquantum-algorithmsquantum-computingquantum-cryptography

Resources

Readme
MIT license
Activity

Stars

5 stars

Watchers

1 watching

Forks

1 fork
Report repository

Releases

Packages

Used by

Contributors

Languages