World by Tools for Humanity

World ID adoption is bottlenecked by developer friction. Third-party developers currently test integrations against production environments or build custom mocks – 82% report spending 6+ hours/week troubleshooting mismatched responses and credential edge cases (source: Q3 Dev Satisfaction Survey, n=112). Errors in staging propagate to production, causing 23% of new World ID implementations to experience ≥1-week launch delays due to failed verification flows.

This feature eliminates integration friction via a zero-setup sandbox. Business case: 2,300 monthly active developer organizations × 4.1 hours/week saved × $72/hour blended dev cost × 50 weeks = $34M/year recoverable (source: Dev orgs from Worldcoin dashboard; time savings from survey; dev labor cost from Regional Cost Benchmarks for global dev population). If adoption reaches 40%: $13.6M/year. This does not include secondary revenue from increased API calls (+17% projected by sales model) or reduced support tickets (estimated $2.2M/year savings).

This is a self-service environment with live debug tracing and synthetic identity generation. It is not a replacement for production environments, a credential issuance system, or local SDK simulation.

Stripe solves this with stateful test mode but lacks credential simulation. Auth0 offers mocks with fixed data but no verification step debugging.

Our wedge is the debug console showing verification internals because it directly addresses the "why did this fail?" pain point engineers currently solve with manual logging.

WHO / JTBD: When a backend engineer at a fintech startup implements World ID verification, they need to validate end-to-end flows against edge cases (expired credentials, regional restrictions) without deploying to production or building custom mocks – so they can ship integrations faster with fewer bugs.

WHERE IT BREAKS: Developers currently write Python scripts to mock Orb responses or risk testing with real credentials in staging environments. Both approaches require manual credential rotation, lack scenario controls, and provide no visibility into intermediate verification states. Production failures emerge from uncaught gaps – like not handling revoked credentials or mismatched uniqueness flags.

WHAT IT COSTS:

Aggregate annual cost: $34M in recoverable developer effort + $1.1M in lost conversions.
JTBD statement: "When I build with World ID, I want a preconfigured environment showing exactly how responses flow through the system, so I can catch errors before deployment."

The core mechanic synthesizes verifiable credentials using deterministic test keys and exposes intermediate state through instrumentation hooks. Four key components:

1. Test Wallet Generator: Creates synthetic Wallets with adjustable parameters (credential status, country, age)
2. Scenario Orchestrator: API-triggered conditions (e.g., "simulate credential revoked mid-flow")
3. State Inspector: Returns machine-readable verification logs at each SDK handoff
4. Debug Console: Real-time visualization of proof validation stages

Primary Flow:

1. Developer loads sandbox dashboard from Worldcoin developer portal
2. Toggles test scenario (e.g., "Age Over 18 + Uniqueness Check Failed")
3. Generates test deep link → scans with World App test mode
4. Inspects verification chain in debugger:

┌───────────────────────────── World ID Debug Console ────────────────────────────┐
│ SCENARIO: Uniqueness check failed                          Export Logs [↓]       │
├───────┬─────────────────────────────────┬────────────────────────┬───────────────┤
│ Step  │ Component                       │ Input                  │ Result        │
├───────┼─────────────────────────────────┼────────────────────────┼───────────────┤
│ 1     │ Wallet Response                │ ✅ Valid credential     │ Code: 200     │
│ 2     │ Uniqueness Verification        │ ❌ Duplicate detected   │ Error: W04    │
│ 3     │ Policy Engine                  │ ⚠ Fail closed           │ DENIED        │
└───────┴─────────────────────────────────┴────────────────────────┴───────────────┘

1. Copies failing code (W04) into integration error handler

Key Decisions:

1. Choice: Simulate revocation via time-based expiry, not manual toggle
   Rejected: Manual toggles require UI interaction per test → slow for CI
   Why: Automation requires deterministic behavior

2. Choice: Expose raw verification codes (W04) instead of generic errors
   Rejected: Abstracted messages hide fixable flaws
   Why: Empowers developers to handle edge cases

Integration: Accessed via [Developer Portal] > "Sandbox" tab. Unlocks after API key creation.

Phase 1 — MVP (6 weeks)
US#1 — Credential Simulation

• Given a developer in the sandbox environment
• When selecting "Generate Test Wallet" with age=22
• Then receive a verifiable credential with "birthdate": "2002-01-01" in SDK response body

US#2 — Debug Trace

• Given a failed uniqueness check
• When the verification pipeline executes
• Then the debug console shows step 2 error W04 within 200ms

Failure Mode Coverage:

• If scenario simulation fails >1% of requests, sandbox auto-rolls back to last stable config
• If debug console latency >500ms p95, throttle synthetic traffic by 50%

Out of Scope (Phase 1):

Phase 1.1 (4 weeks): Custom proof expiration times, CI/CD webhooks
Phase 1.2 (6 weeks): Biometric simulation, rate limit testing

Primary Metrics:

Guardrail Metrics:

What We Are NOT Measuring:

1. "Sandbox logins" – Counts curiosity not usage depth
2. "Generated test wallets" – Could inflate via scripting abuse

Risk 1: Synthetic Credentials Exfiltrated to Production

• Likelihood: Low | Impact: High
• Trigger: Sandbox credential used in prod endpoint
• Mitigation: All test credentials signed with dedicated dev key (distinct header). Revocation sweep every 15m.
• Owner: Security Lead (R. Gupta) — implement by design freeze

Risk 2: Debug Data Leaks PII

• Likelihood: Medium | Impact: Critical
• Trigger: Real user data appears in debug logs
• Mitigation: Data sanitization pipeline with 3-stage filter (⚠ GDPR Article 4 validation needed)
• Owner: Compliance Officer (T. Kwan) — audit pre-launch

Risk 3: Low Adoption Due to Setup Friction

• Likelihood: Medium | Impact: Medium
• Trigger: <30% of new devs activate sandbox in D30
• Mitigation: One-click sandbox activation from main API docs (UX owner: L. Chen)

Kill Criteria (90 days):

1. Production verification errors increase >2.5% absolute
2. Zero unique debug console users after 10,000 sandbox visits
3. Credential leakage incident occurs

Decision: Should we simulate partial failures?
Choice Made: Full failure states only
Rationale: Partial failures introduce non-determinism—devs need binary pass/fail to map to error codes

Decision: How to isolate test credentials?
Choice Made: Dedicated cryptographic root not connected to prod
Rationale: Key rotation would compromise all sandbox envs → unacceptable security debt

Decision: Real-time logs vs. post-hoc?
Choice Made: Real-time streaming
Rationale: 92% of devs cite "seeing state transitions" as critical (survey) — tradeoff: +40% infra cost

Before/After Narrative:
Before: Elena (fintech backend lead) spends Tuesday debugging why Indonesian user verifications fail. Her team built a credential proxy that crashed when testing expiration logic. They deploy anyway; production fails at 2AM. Fix takes 3 days.

After: Elena loads the sandbox, sets "Credential Expiry: 5s", triggers a test. The debugger shows the failure at the uniqueness check step with error W04. She adds a handler for that code and ships in 45 minutes.

Pre-Mortem:
It is 6 months from now and this feature failed. The 3 most likely reasons:

1. Legal blocked credential simulation under new EU digital identity laws (EC proposal 2027)
2. Debug console added 3+ clicks per test vs. CLI alternatives
3. Competitors copied the debug concept but added GitHub Actions integration first

Success Scenario:
Worldcoin's CTO cites 40% faster enterprise integrations at earnings call. Support tickets for verification errors drop 75%. Developers tweet screenshots of the debugger with "finally understood why my app failed".