Steven GellerQuantum Computing, End to End

Book contents

Current section

Part IX. Company and Investing

  1. The Quantum Company Landscape
  2. Hardware Modality Diligence
  3. Software and Developer-Platform Diligence
  4. Error-Correction-Stack Diligence
  5. Application-Company Diligence
  6. Supply-Chain and Infrastructure Diligence
  7. Market Timing and Wedge Selection
  8. Moats, Partnerships, and Standards
  9. Reading Roadmaps Like an Operator
  10. Investment Memo and Startup Thesis Templates

Part IX. Company and Investing · Chapter 79

Market Timing and Wedge Selection

In quantum, the same idea can be a company, a research project, or a donation to the field depending on when you start it. This chapter is about choosing the narrow entry point — the wedge — that creates evidence before the future arrives.

Artifact
In this chapter 9 sections

Choose a narrow buyer pain with a present budget, short proof cycle, reusable technical asset, and a credible expansion path; reject wedges whose revenue requires bespoke labor, an unstated hardware breakthrough, or privileged access that customers can readily replace.

An initial market wedge should purchase evidence while generating revenue. The best early offer solves a present buyer pain, finishes quickly enough to learn, leaves a reusable technical asset, and opens a plausible adjacent workflow. The worst looks like progress while consuming all senior engineering time in bespoke delivery.

A wedge is a sequence of paid tests

The wedge ledger records buyer, budget evidence, painful event, paid deliverable, proof-cycle days, reusable artifact, custom hours, upstream hardware or interface dependency, renewal route, expansion hypothesis, maximum downside, and expiry. Each item is measured; a broad market-size estimate cannot compensate for no present buyer.

Dated timing table: pain, budget, proof cycle, expansion

GAO and the National Academies frame current technical uncertainty. ACM’s artifact policy supplies useful reuse criteria. OpenQASM, Qiskit, and Cirq establish versioned integration points at the cutoff. VQE offers a concrete workflow family, while the benchmarking review ensures the early service measures a buyer task rather than an isolated device statistic.

Market Timing and Wedge Selection: claim and source ledger, frozen 14 August 2026
No.ClaimEvidence
1Current quantum markets remain constrained by technical maturity and end-to-end performance evidence.U.S. Government Accountability Office, Quantum Computing and Communications: Status and Prospects (2021)
National Academies of Sciences, Engineering, and Medicine, Quantum Computing: Progress and Prospects (2019)
Timothy Proctor et al., Benchmarking quantum computers (2025)
2Reproducible artifacts and standard interfaces can turn service work into transferable product learning.Association for Computing Machinery, Artifact Review and Badging (2026)
OpenQASM Technical Steering Committee, OpenQASM 3 specification (2026)
3Official SDK and language interfaces establish current integration surfaces but may change over time.IBM Quantum, Qiskit documentation (2026)
Google Quantum AI, Cirq documentation (2026)
4A VQE-backed wedge inherits hybrid sampling and optimization costs, and its benchmark must still measure the buyer task rather than an isolated quantum subsystem.Alberto Peruzzo et al., A variational eigenvalue solver on a photonic quantum processor (2014)
Timothy Proctor et al., Benchmarking quantum computers (2025)

A developer tool produces learning but weak retention

FIELDS = {"budget_evidence": str, "proof_cycle": dict, "service_intensity": dict,
          "reusable_asset": str, "expiry": str, "hardware_trigger": str, "source_id": str}
def select(wedges, maximum_days, maximum_hours):
    errors = []
    eligible = []
    for name, wedge in wedges.items():
        missing = [field for field, kind in FIELDS.items()
                   if field not in wedge or type(wedge[field]) is not kind or not wedge[field]]
        days, hours = wedge.get("proof_cycle", {}), wedge.get("service_intensity", {})
        if type(days.get("value")) is not int or days.get("unit") != "days":
            missing.append("proof_cycle_schema")
        if type(hours.get("value")) is not int or hours.get("unit") != "hours/customer":
            missing.append("service_intensity_schema")
        if missing:
            errors.append(name + ":" + ",".join(sorted(set(missing))))
        elif days["value"] <= maximum_days and hours["value"] <= maximum_hours:
            eligible.append(name)
    return {"decision": "invalid" if errors else (eligible[0] if len(eligible) == 1 else "no-wedge"),
            "errors": errors, "eligible": sorted(eligible)}
wedges = {
    "benchmark-service": {"budget_evidence": "signed paid discovery", "proof_cycle": {"value": 30, "unit": "days"},
                          "service_intensity": {"value": 30, "unit": "hours/customer"},
                          "reusable_asset": "workload and result schema", "expiry": "2027-02-14",
                          "hardware_trigger": "two portable backends", "source_id": "scenario:buyer-LOI"},
    "bespoke-consulting": {"budget_evidence": "approved project", "proof_cycle": {"value": 90, "unit": "days"},
                           "service_intensity": {"value": 160, "unit": "hours/customer"},
                           "reusable_asset": "customer-only report", "expiry": "2026-11-14",
                           "hardware_trigger": "none before renewal", "source_id": "scenario:SOW"},
    "future-optimizer": {"budget_evidence": "no current budget", "proof_cycle": {"value": 365, "unit": "days"},
                         "service_intensity": {"value": 80, "unit": "hours/customer"},
                         "reusable_asset": "prototype", "expiry": "2026-11-14",
                         "hardware_trigger": "logical resource gate", "source_id": "scenario:interviews"}}
base_result = select(wedges, 60, 60)
bad_wedges = {**wedges, "benchmark-service": {key: value for key, value in wedges["benchmark-service"].items() if key != "expiry"}}
bad_result = select(bad_wedges, 60, 60)
tight_result = select(wedges, 60, 20)
assert base_result["decision"] == "benchmark-service" and base_result["eligible"] == ["benchmark-service"]
assert bad_result["decision"] == "invalid" and "expiry" in bad_result["errors"][0]
assert tight_result["decision"] == "no-wedge" and tight_result["eligible"] == []
print(f"PASS: 79 wedge workbook selected={base_result['decision']} invalid={bad_result['errors']} hours20={tight_result['decision']}")

A benchmark service has a 30-day proof cycle, produces a reusable workload and result schema, and needs 30 custom hours. Bespoke application consulting consumes 160 hours and leaves no common artifact. A future fault-tolerant tool has strong technical interest but no present buyer budget. The service wins only with a six-month productization expiry.

Artifact contract. A dated buyer/pain/proof/reuse/expansion table with executable bounded-score and kill checks. No wedge passes without present budget evidence, a reusable asset, maximum service intensity, expiry, and a hardware-dependency trigger.

Market-wedge learning and dependency ledger: inspected record
Candidate wedgeProof cycleCustom hoursReusable artifact
Benchmark service30 days30workload and result schema
Bespoke consulting90 days160none shared
Fault-tolerant optimizerunknown80prototype only; no current buyer
Training14 days20course assets; weak expansion

Exact validation command: python3 tools/validate_briefs.py --briefs data/editorial_briefs_64_87.json --from 64 --through 87 --check-rewritten-sources --execute-artifacts

The wrong early revenue can consume the roadmap

Sell the bounded benchmark, instrument delivery time and reuse, and stop if the second and third customers do not reuse the same core artifact. Do not count custom analysis as product adoption. The expansion path is a repeatable evaluation platform; if it does not emerge before expiry, retain the service economics or close the thesis.

Market-wedge learning and dependency ledger A market wedge as a sequence of paid learning loops. Market-wedge learning and dependency ledger buyer painpresent budget paid test reusableartifact expiryor expand
Figure 79.1. The benchmark service has a short proof cycle and reusable output. Productization expires if later customers do not reuse the artifact.

Compare wedges with downside constraints

Prompt. Compare three initial wedges for a quantum software or infrastructure team.

Deliverable. Buyer, current budget evidence, proof-cycle length, paid deliverable, reusable asset, service hours, upstream dependency, expansion path, and kill date.

Pass condition. The chosen wedge has a present buyer, bounded custom work, a reusable artifact, and a milestone that can invalidate the expansion thesis.

Model answer: narrow benchmark service with an expiry

Format. Benchmark-service wedge selected with a six-month productization expiry.

The model answer selects the benchmark service because it has a present buyer, short proof cycle, capped customization, and reusable output. It explicitly refuses to call this a permanent product wedge. The evaluator fails the choice if custom hours exceed 60 or reuse is absent. Six months later the team must show common artifacts across customers or choose again.

Verification. The evaluator rejects the consulting-heavy and hardware-dependent alternatives and fails the selected wedge if reuse or service-intensity bounds are removed.

Companion work

Artifacts for this chapter

These entries resolve to checked-in local source. Commands are reproduced exactly from the chapter manifest, and source-embedded fixtures are exported as direct downloads.

  1. Reproduce or test

    python3 tools/validate_briefs.py --briefs data/editorial_briefs_64_87.json --from 64 --through 87 --check-rewritten-sources --execute-artifacts

Provenance

Sources and review

  1. U.S. Government Accountability Office. Quantum Computing and Communications: Status and Prospects. GAO. 2021government technology assessment
  2. Association for Computing Machinery. Artifact Review and Badging. ACM Publications. 2026official reproducibility policy
  3. OpenQASM Technical Steering Committee. OpenQASM 3 specification. Linux Foundation Joint Development Foundation. 2026official technical specification
  4. IBM Quantum. Qiskit documentation. IBM. 2026official documentation
  5. Google Quantum AI. Cirq documentation. Google. 2026official documentation
  6. Alberto Peruzzo et al.. A variational eigenvalue solver on a photonic quantum processor. Nature Communications. 2014primary paper
  7. Timothy Proctor et al.. Benchmarking quantum computers. Nature Reviews Physics. 2025peer-reviewed perspective
  8. National Academies of Sciences, Engineering, and Medicine. Quantum Computing: Progress and Prospects. National Academies Press. 2019consensus study report

The load-bearing claims in the chapter are mapped inline to this registered source set. A citation supports only the bounded claim beside it.

Cite this chapter