Executive Summary: Private Document Processing API

Product Definition

What: A self-hosted document OCR + extraction API that processes images/PDFs through a local vision model (qwen3-vl:8b) and returns structured JSON. Zero cloud vision processing — documents never leave your infrastructure. Designed for privacy-conscious businesses (legal, healthcare-adjacent, financial services, EU GDPR compliance).

Current State: 486 lines of working code (document_sorter.py) that:
- Receives images via Telegram DM → saves to /tmp/dropbox/ → base64 encodes → sends to Gaming PC Ollama qwen3-vl:8b
- Extracts: {vendor, date, category, amount} with strict taxonomy
- Builds filename: YYYY-MM-DD_Vendor_Category_$Amount.ext
- Uploads to Google Drive (currently blocked — Google account suspended)
- Cleans up temp files in finally block
- Uses keep_alive: 0 to immediately unload vision model and free VRAM

Gap to Revenue: The code works for personal use. To sell it as an API service requires: always-on GPU, multi-tenant auth, web API (not Telegram), billing, PDF support, and output storage (not Google Drive).

Market Analysis

Cloud OCR Pricing (competitive benchmarks)

The privacy moat: None of these providers can say "your documents never touch a cloud server." For legal firms, healthcare-adjacent services, financial advisors, and EU businesses under GDPR — this is compliance, not preference.

Target Market Segments

Market validation:
- Paperless-ngx has 50K+ GitHub stars — proven demand for self-hosted document management
- CleanRoll.ai raised funding for CRE rent roll extraction — validates OCR-as-a-service niche
- Mistral OCR 3 launched December 2025 with $1/1K pages pricing — proves market pressure on cloud pricing

Technical Architecture

Current Implementation (v0.1 - Personal Use)

Telegram DM (image) → /tmp/dropbox/ → base64 → HTTP POST to Gaming PC Ollama
                                              ↓
                                        qwen3-vl:8b inference (120s timeout)
                                              ↓
                                        JSON extraction → filename builder
                                              ↓
                                        Google Drive upload (BLOCKED)
                                              ↓
                                        👍 Telegram reaction

Hardware dependency: Gaming PC (3080 Ti, 12GB VRAM) must be ON and connected via Tailscale. Windows + Ollama + keep_alive: 0.

Required Architecture (v1.0 - Revenue Service)

Client POST /api/v1/extract (image/PDF + api_key)
              ↓
        FastAPI auth layer (rate limit, tenant isolation)
              ↓
        PDF → image conversion (if needed) via pdf2image
              ↓
        Local Ollama OR always-on GPU endpoint
              ↓
        qwen3-vl:8b inference (15-30s per page)
              ↓
        JSON extraction → structured output
              ↓
        MinIO S3-compatible storage (self-hosted, not AWS)
              ↓
        Webhook callback OR polling endpoint for results
              ↓
        Stripe metered billing (per-page + monthly base)

Critical change: Replace Google Drive with MinIO (self-hosted S3-compatible object storage) or local filesystem with CDN. Never touch AWS/GCP/Azure for file storage.

Gap Analysis: Current → Revenue

Total engineering effort: 4-6 weeks for MVP (one person, nights/weekends).

Hardware Investment Required

Current Setup Bottlenecks

Recommended Hardware Upgrades

Option A: Dedicated GPU Server (Recommended)

Power consumption: ~150W under load, ~30W idle = ~$15-25/mo electricity.

Alternative: Used RTX 2060 Super 8GB ($120-150) — enough for qwen3-vl:8b, cheaper entry.

Option B: NVIDIA Jetson Orin Nano

Tradeoffs:
- Pros: Lower power (~$5/mo), smaller footprint, purpose-built for edge AI
- Cons: ARM architecture (some Python wheels don't exist), slower inference than desktop GPU, 8GB RAM limits concurrent jobs

Recommendation: Option A (used RTX 3060 + SFF PC). More flexible, faster inference, easier troubleshooting.

Option C: Upgrade Beelink (Not Recommended)

Intel N150 has no PCIe slot for GPU. External GPU via Thunderbolt/USB4: $300 enclosure + $200 GPU = $500, more complex, lower bandwidth. Skip.

Cost Model: Self-Hosted vs Cloud

Monthly Operating Costs (Self-Hosted)

Pricing Strategy

Target: Undercut cloud providers by 50% while offering privacy premium.

Break-even: At $79/mo × 10 customers = $790/mo revenue. COGS $47/mo. Gross margin 94%.

Dev/Test Cycles

Phase 1: Hardware (Week 1)

• Acquire used RTX 3060 + SFF PC
• Install Ubuntu 22.04 LTS, Ollama, qwen3-vl:8b
• Verify inference speed: target <30s per page
• Configure Tailscale static IP or Cloudflare Tunnel

Phase 2: Core API (Weeks 2-3)

• FastAPI scaffolding with auth (API keys)
• Image upload endpoint (sync) → returns job_id
• Async job processing with Celery + Redis
• MinIO setup for result storage
• Webhook callback system

Phase 3: PDF Support (Week 4)

• pdf2image integration for multi-page PDFs
• Page-by-page processing with progress tracking
• Zip output for multi-page docs
• Bulk upload endpoint

Phase 4: Billing (Week 5)

• Stripe metered billing integration
• Usage tracking per API key
• Automatic overage handling
• Invoice generation

Phase 5: Dashboard (Weeks 6-7)

• Minimal web UI: job status, usage charts, API key management
• Status page with uptime metrics
• Error logs view (sanitized)

Phase 6: Security Hardening (Week 8)

• Rate limiting (prevent abuse)
• Input validation (prevent injection)
• Audit logging (who processed what when)
• TLS termination via Cloudflare Tunnel
• Fail2ban for SSH/API brute force

Testbench Demo: Go/No-Go Criteria

Test 1: Inference Performance

Setup: Single page receipt, qwen3-vl:8b, RTX 3060 12GB

Target:
- Cold start (model not loaded): <60 seconds
- Warm inference: <20 seconds per page
- Concurrent requests (3): <90 seconds each

Go if: Average <30s per page under load

Test 2: Accuracy Benchmark

Dataset: 100 documents (mix of receipts, invoices, contracts)

Target:
- Vendor name extraction: >90% accuracy
- Date extraction: >95% accuracy (correct format)
- Amount extraction: >95% accuracy (within $0.01)
- Category classification: >85% accuracy

Go if: Overall field extraction >90% without human correction

Test 3: Uptime & Reliability

Duration: 7 days continuous operation

Target:
- Uptime: >99% (excluding planned maintenance)
- Zero memory leaks (Ollama stays responsive)
- Graceful degradation under load (queue management)
- Automatic recovery from GPU OOM

Go if: Zero unplanned outages, <5min recovery time

Test 4: End-to-End Latency

Scenario: Client POST → processing → webhook callback

Target:
- P50 latency: <45 seconds
- P95 latency: <120 seconds
- P99 latency: <300 seconds (large PDFs)

Go if: P95 <120s for single-page documents

Test 5: Cost Validation

Measurement: 30-day electricity + bandwidth

Target:
- Electricity: <$40/mo
- Bandwidth: <100GB/mo (no overage)
- Hardware: no thermal throttling, <80°C GPU

Go if: Monthly COGS <$50

Risk Assessment

Recommendation

Go/No-Go Decision: CONDITIONAL GO

Proceed if:
1. ✅ Can invest $500-700 in dedicated GPU hardware within 30 days
2. ✅ Willing to spend 6-8 weeks part-time on MVP
3. ✅ First 3 paying customers identified (even if just "would you pay for this?" conversations)
4. ✅ Accept 6-month payback period on hardware

Defer if:
- ❌ Cannot guarantee always-on GPU (Gaming PC unreliable)
- ❌ Not willing to build web UI (Telegram-only won't scale to B2B)
- ❌ No LLC/liability protection (healthcare/legal adjacent customers)

Phased Approach

Phase 0 (Now):
- Validate demand: 5 conversations with law firms/financial advisors
- Price test: "Would you pay $79/mo for unlimited private OCR?"
- Build waitlist

Phase 1 (Month 1):
- Buy hardware, set up dedicated inference server
- Build async API + MinIO storage
- Dogfood with personal documents

Phase 2 (Month 2):
- Stripe integration, billing
- Onboard 3 beta customers at $29/mo (discounted)
- Iterate on extraction accuracy

Phase 3 (Month 3):
- Dashboard web UI
- Public launch at $79/mo
- Target: 10 customers ($790/mo) → break even

Conservative projection: 10 customers by Month 6 = $790/mo revenue, $47/mo COGS, $743/mo gross profit. Annual: ~$8,900 gross profit on ~$700 hardware investment.

Appendix: Competitive Moat Analysis

Why customers choose self-hosted over cloud:

Differentiation from Paperless-ngx:
- Paperless: document management (storage, tagging, search)
- Us: document processing API (OCR, extraction, structured output)
- Complementary: customers use both

Differentiation from cloud OCR:
- Cloud: 99.9% uptime, infinite scale, higher cost, privacy risk
- Us: 99% uptime, limited scale, lower cost, zero privacy risk

The moat isn't features — it's zero trust architecture that cloud providers cannot replicate by definition.

Document version: 2026-04-19
Status: Draft for review
Next step: Matt's go/no-go decision, then Phase 0 validation