Future Plans: VM Infrastructure & Self-Hosted Features

Goal: Leverage our self-hosted Hetzner infrastructure (Firecracker microVMs, dedicated servers, bare metal control) to build features that cloud-dependent competitors fundamentally cannot replicate.

Status: Feature catalog for prioritization. Nothing here is committed — pick what creates the most value with the least cost.

Competitive Context

What competitors offer (Bolt.new, Lovable, v0, Replit, Bubble)

• Prompt-to-app generation (all of them)
• Browser-based preview (all of them)
• GitHub export / code ownership (Bolt, Lovable, v0)
• Supabase/Firebase integrations (Lovable, Bolt)
• Figma-to-code (v0 only)
• Collaborative editing (Replit)
• Hosting included (Bubble, Replit)

What NONE of them offer

• AI agent that operates the platform after building it (monitoring, fixing, deploying)
• Hardware-isolated sandboxes per customer (Firecracker microVMs)
• WhatsApp-native platform management (build + operate from your phone)
• Full-stack environment snapshots (code + database + config = time travel)
• On-premise / EU data residency guarantee (customer data never leaves your servers)
• Local AI inference (no external API dependency for routine tasks)

Our unique advantage

We own the metal. Every competitor runs on AWS/GCP/Vercel. They pay per-second, per-request, per-token. We pay flat monthly. This means:

• We can offer persistent, always-on environments at zero marginal cost
• We can run local AI inference and undercut everyone on pricing
• We can guarantee data sovereignty (EU servers, no third-party cloud)
• We can offer Firecracker-level isolation that no shared-cloud platform matches

Feature Catalog

Category A: Immediate Leverage (uses existing infrastructure, low build effort)

A1. Self-Healing Platforms

What: Vitto monitors deployed customer platforms. When something breaks (crash, memory leak, 500 errors, dependency vulnerability), Vitto autonomously diagnoses, writes the fix, tests it in a sandboxed Firecracker VM, and deploys. Customer gets a WhatsApp message: "Your checkout API was returning 500s. Found a null pointer in order validation. Fixed and deployed. Here's the diff."

Why it matters: No platform builder self-heals. Customers discover their app is broken from their own users complaining. This makes Vitto the first AI that operates the platform it built.

What exists today:

• Firecracker VMs for safe testing (sandbox-orchestrator)
• 4-phase workflow: ANALYZE, PLAN, EXECUTE, VERIFY (phase-executor)
• WhatsApp channel integration (S217-218)
• Vitto agent loop with monorepo tools

What's missing:

• Health monitoring per deployed platform (cron-based HTTP probes + log analysis)
• Diagnostic agent that reads logs inside the VM
• Auto-trigger loop: detect issue, create sandbox, fix, test, deploy
• Customer notification via WhatsApp/web with diff summary

Effort: Medium (mostly wiring existing pieces) Infra cost: Zero (uses existing Firecracker VMs) Revenue impact: High — this is a premium feature customers will pay for

A2. WhatsApp-Native Platform Operations

What: Not just "build me a platform" — ongoing operations entirely through WhatsApp:

• "How many orders came in today?" — Vitto queries the platform's database, responds with summary
• "Put the summer collection on sale, 20% off" — Vitto modifies platform, deploys, confirms
• "Site is slow" — Vitto runs diagnostics, identifies issue, fixes it
• "Send a notification to customers who ordered last week" — Vitto executes
• "Show me last month's revenue" — Vitto generates a chart, sends as image

Why it matters: The business owner never opens a dashboard. Their digital business is operated through a chat thread. No competitor offers this — they all require you to open their web IDE.

What exists today:

• WhatsApp channel + cross-channel bridge (S217-218)
• Vitto agent loop with tool execution
• Firecracker VMs with SSH access for diagnostics
• Sandbox tool proxy (exec, read-file, write-file)

What's missing:

• Per-customer platform awareness (which VM/environment belongs to which customer)
• Database query tool (read-only SQL/MongoDB access inside customer's VM)
• Media generation for charts/reports (send as WhatsApp image)
• Operation templates (common tasks as single-message shortcuts)

Effort: Low-Medium (80% of the pipeline exists) Infra cost: Zero Revenue impact: Very high — this is the "Jarvis for your business" story

A3. Instant Platform Preview Marketplace

What: A marketplace of platform templates where every entry is a live, interactive demo running in a Firecracker VM. Customers browse, click into a running app, interact with it. "Use this template" forks it into their space instantly (sparse rootfs copy, ~500ms).

Why it matters: Every competitor shows screenshots or static previews. Nobody lets you interact with a running app before choosing it. The fork is instant because Firecracker sparse copies share disk blocks.

What exists today:

• Firecracker VMs with Chrome + VNC
• Sparse rootfs copying (FirecrackerService)
• Platform generation pipeline
• Module generation with template support

What's missing:

• Template registry (metadata, categories, live VM pool)
• Public VNC/noVNC viewer (read-only, no auth required)
• Fork flow: sparse copy + customize prompt
• Template contribution pipeline (successful platforms become templates)

Effort: Medium Infra cost: Low (pool of ~5-10 always-on demo VMs, ~2 GiB each = ~20 GiB) Revenue impact: High — reduces time-to-value, increases conversion

Category B: Differentiating Features (moderate build effort, unique capabilities)

B1. Platform Time Machine

What: Every significant change Vitto makes to a customer's platform gets a Firecracker snapshot — the entire running state (code, database, config, running processes) frozen in time. Customer says "go back to how things were on Tuesday at 3pm" and the entire environment restores in ~500ms. Not just code revert — database state, environment variables, assets, everything.

Why it matters: No platform builder offers full-environment time travel. Wix has "undo." Webflow has version history. Nobody can restore a complete running environment to an arbitrary point in time.

What exists today:

• Firecracker snapshot/restore (SnapshotService, ~28ms restore)
• vm-session-manager with snapshot-on-release
• Session tracking per user

What's missing:

• Snapshot-on-change hooks in the generation pipeline (not just on release)
• Snapshot metadata store (timestamp, description, trigger, before/after diff)
• Storage tiering: recent on NVMe, older on Hetzner Storage Box ($0.008/GB/mo)
• UI timeline component showing snapshot history with restore button
• Snapshot diffing (what changed between two points)

Effort: Medium Infra cost: Low (Hetzner Storage Box for cold snapshots, ~$4/TB/mo) Revenue impact: High — insurance policy that customers will pay premium for

B2. Live Platform Branching (A/B Environments)

What: Customer says "I want to test a redesigned checkout flow." Vitto forks their entire platform into a parallel Firecracker VM — same data, different code. Customer gets two live URLs. They can test with real users, compare metrics. Merge the winner. Kill the loser.

Why it matters: This is git branching for entire running platforms, not just code. Includes database state, config, runtime. Shopify doesn't have this. Bubble doesn't have this. Closest analogy is Vercel preview deployments, but those don't include database state.

What exists today:

• Sparse rootfs copies (share disk blocks, fast fork)
• Snapshot/restore infrastructure
• Multiple concurrent VMs per user (sandbox-orchestrator capacity)

What's missing:

• Fork flow: snapshot parent VM, create child with sparse copy + new branch
• Branch metadata (parent, diff, creation time, traffic split)
• Traffic splitting / URL routing (branch.platform.customer.com)
• Merge/promote flow (make branch the new primary)
• Metrics comparison dashboard (branch A vs branch B)

Effort: Medium-High Infra cost: Low per branch (sparse copy shares most disk blocks, ~2 GiB RAM per branch VM) Revenue impact: High — enterprise feature, upsell to pro/enterprise tiers

B3. EU Data Sovereignty & On-Premise Guarantee

What: Customer data never leaves Hetzner Germany/Finland. No AWS, no GCP, no Cloudflare in the data path. Full GDPR compliance with a provable data residency guarantee. For enterprise customers: dedicated Firecracker VMs on dedicated hardware, network-isolated.

Why it matters: Every competitor (Bolt, Lovable, Replit, Bubble) runs on US cloud providers. EU customers in regulated industries (healthcare, finance, government) cannot use them. This is a hard requirement, not a nice-to-have. Being the only AI platform builder with provable EU data residency is a massive competitive moat in Europe.

What exists today:

• Servers in Germany (Hetzner Falkenstein)
• No external cloud dependency for VM execution
• API keys for external LLMs are the only data leaving the EU

What's missing:

• Local AI inference for routine tasks (eliminates external LLM dependency — see B4)
• Data residency documentation / compliance page
• SOC 2 / ISO 27001 certification path (long-term)
• Per-customer network isolation (VLAN per enterprise customer)
• Audit logging: every data access logged with timestamp + user + location

Effort: Low (documentation) to High (certification) Infra cost: Zero for basic compliance; moderate for per-customer isolation Revenue impact: Very high for EU enterprise market — no competitor can match this

B4. Local AI Inference (Hybrid LLM Strategy)

What: Run local LLM inference (Llama 3, Mistral, Qwen) on a GPU-equipped Hetzner server for routine tasks: code generation for simple modules, content writing, image generation (Stable Diffusion), classification, summarization. Reserve Claude/GPT for complex reasoning, architecture decisions, and novel problem-solving.

Why it matters:

• Cost: Local inference is 10-50x cheaper per token than API calls at volume. Break-even at ~6.8M tokens/month per research. Above that, local wins dramatically.
• Speed: No network round-trip, no rate limits, no queue. Sub-100ms for small models.
• Privacy: Customer data stays on your servers. No third-party sees prompts or responses.
• Reliability: No dependency on external API outages (Anthropic/OpenAI downtime = your downtime today).
• Pricing disruption: If competitors pay $0.015/1K tokens to OpenAI and you pay $0.001/1K locally, you can offer unlimited AI interactions at a flat rate.

What exists today:

• BaseLLMProvider with provider-agnostic routing (Claude, OpenAI, Gemini)
• ProviderFactory for dynamic provider selection
• Cost tracking per conversation (CostGuard)

What's missing:

• GPU server (Hetzner GEX44 with RTX 4090, ~$221/mo; or rent GPU cloud)
• LocalLLMProvider implementing BaseLLMProvider interface
• vLLM or llama.cpp serving layer on the GPU server
• Routing logic: simple tasks to local model, complex tasks to Claude
• Fine-tuned models for GoGrab-specific code patterns (Angular, NestJS, module generation)

Effort: Medium Infra cost: ~$221/mo for GPU server (pays for itself above ~6.8M tokens/month) Revenue impact: High (cost reduction) + enables unlimited AI pricing tier

Category C: Platform-Defining Features (higher effort, game-changing)

C1. Customer Dev Environments (Persistent Workspaces for Everyone)

What: Extend the Internal Dev Server concept from executives to paying customers. Premium plan customers get a persistent, always-warm development environment for their platform. They message Vitto: "Add a discount code field to checkout." Vitto makes the change in their dedicated worktree, runs tests, shows a preview — all in seconds, not minutes.

Why it matters: This is GitHub Codespaces for non-developers, operated by an AI. A restaurant owner has a full dev environment for their ordering platform without knowing what a dev environment is. Vitto abstracts it entirely.

Tiered offering:

• Free tier: Ephemeral Firecracker VMs (current, 2 GiB, cold boot, ~10s start)
• Pro tier: Persistent worktree on shared server (fast, warm, ~3s start)
• Enterprise tier: Dedicated Firecracker VM (isolated, snapshotable, custom resources)

What exists today:

• Firecracker VMs for ephemeral sandboxes
• IDS architecture spec (git worktrees + nspawn)
• Session affinity per user (vm-session-manager)

What's missing:

• Multi-tenant IDS with per-customer namespace isolation
• Customer-facing session management (start/stop/snapshot)
• Usage metering per customer (cgroup stats for billing)
• Tiered provisioning logic in tier-resolver

Effort: High Infra cost: Scales with customers (but incremental cost per customer is low: ~2-3 GiB RAM) Revenue impact: Very high — recurring revenue from persistent environments

C2. AI-Powered Visual Debugging

What: Customer says "the checkout page looks broken." Vitto takes a screenshot of the running platform (via Chrome in Firecracker VM), uses vision AI to identify the visual issue, cross-references with the code, and fixes it. Sends before/after screenshots to WhatsApp.

Why it matters: Visual bugs are the hardest for non-technical users to describe. "It looks weird" is useless for text-based debugging. Vitto can actually see the problem because it has Chrome running inside the VM.

What exists today:

• Chrome + VNC in Firecracker VMs (vm-init.sh)
• Screenshot capability (scrot, xdotool)
• Playwright browser automation
• Vision-capable LLMs (Claude with image input)

What's missing:

• Visual regression pipeline: screenshot before/after changes
• Vision-to-code mapping (screenshot region to component/CSS)
• Automated visual diff (highlight what changed)
• WhatsApp image sending in the fix confirmation flow

Effort: Medium Infra cost: Zero (uses existing VM + Chrome) Revenue impact: Medium-High — solves the #1 frustration of non-technical users

C3. Multi-Agent Platform Assembly Line

What: Instead of one Vitto instance building a platform sequentially, dispatch specialized sub-agents in parallel: one designs the UI, one builds the API, one writes database schemas, one generates test data, one configures authentication. Each runs in its own Firecracker VM. Coordinator agent merges results.

Why it matters: Competitors generate sequentially — each feature waits for the previous one. Parallel generation with hardware-isolated agents is 3-5x faster and produces higher quality (each agent is specialized).

What exists today:

• Sub-Vitto orchestrator (sub-vitto-orchestrator.service.ts)
• Parallel dispatch with concurrency control
• Per-sub-agent VM acquisition
• 4 seeded system agents (Module Gen, Widget, Architecture, Code Quality)

What's missing:

• Specialized generation agents (UI Agent, API Agent, Schema Agent, Auth Agent, Test Agent)
• Merge/conflict resolution for parallel outputs
• Dependency graph for agent ordering (schema before API before UI)
• Progress visualization (which agents are running, what's done)

Effort: High Infra cost: Moderate (multiple concurrent VMs during generation, ~5-10 GiB burst) Revenue impact: High — faster generation = better user experience, less churn

C4. Continuous Platform Intelligence

What: Vitto doesn't just build and forget. It continuously analyzes the customer's platform: tracks user behavior (via lightweight analytics injected into generated code), identifies unused features, suggests improvements, detects performance regressions, recommends SEO fixes. Weekly WhatsApp summary: "Your users aren't using the search feature. Want me to move it to the homepage? Also, your product images are slowing page load by 2s — I can optimize them."

Why it matters: This transforms GoGrab from a "build once" platform into a continuous improvement partner. The platform gets better over time without the customer doing anything. No competitor offers this.

What exists today:

• Vitto agent loop with scheduled triggers
• ProactiveDispatcher for autonomous actions
• WhatsApp notification channel
• Firecracker VMs for safe testing of changes

What's missing:

• Lightweight analytics injection in generated platforms (page views, click heatmaps, errors)
• Analytics aggregation service (collect, summarize, trend-detect)
• Weekly/monthly intelligence report generation
• Proactive improvement pipeline (detect issue, propose fix, wait for approval, execute)
• Customer preferences for autonomous vs approval-required changes

Effort: High Infra cost: Low (analytics are tiny; processing runs on existing infrastructure) Revenue impact: Very high — ongoing engagement, reduces churn, justifies subscription

C5. Zero-Downtime Live Editing

What: Customer's platform is live and serving traffic. Customer says "change the hero text to 'Summer Sale'." Vitto makes the change in a shadow Firecracker VM, verifies it works, then hot-swaps the running VM. Zero downtime. The old VM is kept as a rollback snapshot.

Why it matters: Every platform builder requires a "deploy" step with seconds-to-minutes of downtime. Hot-swapping Firecracker VMs gives truly zero-downtime editing. The customer doesn't even know there was a deployment.

What exists today:

• Firecracker VM creation (~10s)
• Snapshot/restore
• Sparse rootfs copies

What's missing:

• Shadow VM provisioning (clone current, apply change, verify)
• Traffic switchover mechanism (update routing to point to new VM)
• Rollback-on-failure (health check fails, switch back to old VM, <1s)
• Hot-swap coordinator service

Effort: Medium-High Infra cost: Brief double-memory during switchover (~2-4 GiB for ~30s) Revenue impact: Medium — differentiator for customers with uptime requirements

C6. Platform-as-API (Headless Mode)

What: Every platform Vitto generates also exposes a complete REST/GraphQL API automatically. Customers can use the generated platform as a headless backend — their mobile app, their POS system, their IoT device all talk to the same API. Vitto generates OpenAPI/GraphQL schemas, API documentation, and SDK stubs.

Why it matters: Competitors generate web apps only. A restaurant owner gets a web ordering platform AND a mobile-friendly API for their delivery app AND a POS integration — all from the same generation. Headless commerce is a $30B+ market.

What exists today:

• Backend CRUD system (UniverseDataCrudService)
• API generation in the module pipeline
• OpenAPI awareness in the generation prompts

What's missing:

• Auto-generated OpenAPI spec per platform (from schema definitions)
• GraphQL layer auto-generation (optional, alongside REST)
• API documentation page (auto-generated from spec)
• SDK stub generation (TypeScript, Python, cURL examples)
• API key management per customer platform
• Rate limiting per API key

Effort: Medium Infra cost: Zero (runs inside existing VMs) Revenue impact: High — opens entirely new market segment (developers, integrators)

Priority Matrix

Recommended First Moves

Based on impact vs effort, these three features should be discussed first:

1. A2. WhatsApp-Native Ops — 80% of the pipeline exists. Low effort, massive differentiation. Turns every customer's phone into a control panel. No competitor offers this.

2. A1. Self-Healing Platforms — Uses existing Firecracker sandboxes + Vitto agent loop. Transforms Vitto from builder to operator. Premium feature customers will pay for.

3. B3. EU Data Sovereignty (documentation first) — Zero infra cost to start. Write the compliance page, publish the data residency guarantee. Instantly differentiates in the EU enterprise market.

These three features combined cost essentially $0 in additional infrastructure and leverage everything we've already built.

Infrastructure Roadmap (for reference)