Cursor ($29.3B), Lovable ($6.6B), Replit ($9B): The Vibe-Coding Giants All Rent Their Last Mile

Three AI coding companies raised at a combined $45 billion valuation within five months — and none of them owns the machines your app runs on. Cursor hit $2 billion in annualized revenue faster than any B2B software company in history. Lovable went from zero to $100 million ARR in eight months. Replit tripled its valuation in about six months. The gold rush is real. But follow any natural-language spec from prompt to production and you hit the same awkward seam: the companies racing to write your code all bolt "deployment" onto somebody else's infrastructure.

That seam is where the next fight in this market gets decided. Whoever runs the runtime collects the margin, controls the enterprise deal, and decides what "shipped" actually means. Here is what each platform concretely does for that last mile today.

The scoreboard: three raises, one race​

For context: Cursor's $100M-to-$2B run in about thirteen months is the fastest B2B SaaS revenue ramp on record, ahead of Slack, Zoom, and Snowflake. Lovable's backers (CapitalG and Menlo Ventures) bought in after the company became Europe's fastest unicorn. Replit's round tripled its September 2025 valuation of roughly $3B. All three pitches converge on the same demo: describe the app, get running software. The honest question is what "running" means on each platform.

The last-mile matrix: what "deploy" actually does on each platform​

Three philosophies, one pattern: Replit built the furthest down the stack, Lovable abstracted the backend away, and Cursor skipped the runtime entirely. And underneath all three sits rented infrastructure. Let us take them in order.

Replit goes furthest: a real deploy surface on rented ground​

Replit is the only one of the three where deployment is a first-class product surface rather than an export button. Hit deploy and you pick one of four types: Autoscale for variable-traffic web apps and APIs (scale-to-zero, billed by request and resources), Reserved VM for always-on workloads with stable latency (flat monthly fee, machine runs continuously), Static for frontends, and Scheduled for cron-style jobs. SSL and custom domains come along automatically, and the whole thing runs on Google Cloud.

That is genuinely further down the stack than either competitor — one vendor, one bill, from prompt to production URL. The tradeoffs are the ones you would expect from a managed layer. Hosting is US-only, which matters the moment a European customer asks where data lives. The pricing shape punishes the middle: Autoscale's scale-to-zero means cold starts on idle apps, while Reserved VM charges the flat fee whether anyone visits or not. Real-world Agent usage reportedly lands at $50–150 per month once you are actually building, before deploy costs. And strategically, every Replit deployment is still a Google Cloud workload with a Replit margin stacked on top — great for velocity, less great the day you need a region, a GPU, or a compliance posture GCP's menu does not offer at Replit's price.

Replit's 50 million users and 450M-plus repositories make it the closest thing vibe coding has to a platform with gravity. But gravity is not ownership: the company operates the control plane, Google operates the machines.

Lovable's publish button: Supabase all the way down​

Lovable's last mile is the smoothest demo of the three. Generate the app, click Publish, wire a custom domain (paid plans — Pro at $25/month or Business at $50), and you are live with authentication, a Postgres database, and Stripe payments without touching infrastructure. Under the hood, Lovable Cloud is managed Supabase: the database and auth your app depends on live in a Supabase project Lovable controls.

For the target user — a founder with an idea on Tuesday afternoon and a live SaaS on a custom domain by Wednesday — that abstraction is the whole product. The seams show up later, and they are well documented by now. Username-and-password login for your own end users is something you build inside the app; Lovable's own auth story leans on Google. Production apps should move off the shared *.lovable.app suffix onto a custom domain, partly for branding and partly because phishing kits demonstrably also live on that suffix. And the standard migration guide in the wild is titled exactly what you would fear: move hosting to Cloudflare Workers or Netlify plus a Supabase project you own, verify end to end, then unpublish the Lovable app.

Credit where due: Lovable built the escape hatch into the product. Code syncs to GitHub on every plan including free, the database can migrate to a Supabase project you control, and new projects have shipped as server-rendered apps since May 2026. That is more exit ramp than most managed platforms offer. But notice what the exit ramp leads to: another vendor's infrastructure. Lovable abstracted deployment so completely that its own users' migration guides treat the Lovable runtime as scaffolding to outgrow.

Cursor has no last mile — and Origin shows it knows​

Cursor, the $29.3B gorilla, is the starkest case: there is no deploy button at all. Cursor is an AI-native IDE, a VS Code fork where agents write code in your local project. When the code is done, it leaves through the same door as any other editor's output — you push to GitHub, deploy to Vercel or Render or your own servers, and Cursor's job is over. Sixty-seven percent of the Fortune 500 reportedly use it daily, and every one of those companies solves deployment somewhere else.

That is arguably a strength — zero deploy lock-in, zero opinion about your runtime — but it leaves the most valuable step of the workflow on the table. And Cursor is starting to move down the stack. In August 2026 the company launched Origin in early beta: Git-compatible code hosting with repos, pull requests, and two-way GitHub sync built into the Cursor client, with coding agents embedded next to every repo. Enterprise customers already got self-hosted cloud agents in March 2026, keeping execution and secrets inside their own infrastructure.

Origin is code hosting, not compute hosting — no containers, no runtime, no production URL. But the direction is unmistakable: own the surface where code lives first, then follow it toward where code runs. The editor company is becoming an infrastructure company one layer at a time, starting from the top.

The pattern: everyone rents the bottom layer​

Step back and the three strategies rhyme. Replit rents GCP and sells you deploy types. Lovable rents the Supabase-shaped backend and sells you a publish button. Cursor rents nothing and sells you nothing past the editor — yet. In every case, the company capturing the $100M-plus ARR does not operate the machines the generated apps run on.

That matters for three concrete reasons. First, margin: every production workload pays the hyperscaler's price plus the platform's markup, which is why Replit's real monthly cost surprises new users and why Lovable gates custom domains behind paid plans. Second, control: US-only hosting, shared-domain reputation, idle cold starts — each is a limitation inherited from the rented layer, not chosen by the platform. Third, enterprise deals: regulated customers ask where code executes and data rests, and "on our vendor's vendor" is a harder answer than "on infrastructure we operate," which is exactly why Cursor shipped self-hosted agents for enterprise before it shipped anything resembling deployment.

The vibe-coding gold rush's first fight was over who writes the prompt-to-code layer. The next fight is over who runs the runtime — because the runtime is where recurring revenue, switching costs, and enterprise trust actually live.

What owning the fleet buys​

Imagine the same demo — spec in, running app out — where the platform underneath is a Cluster API fleet on machines the operator owns: declarative node lifecycle, GPU pools scheduled with Dynamic Resource Allocation instead of rented inference endpoints, preview environments as cheap namespaces rather than billed deployment types. The deploy button stops being a margin stack on GCP and becomes the product's own moat. Regions, data residency, cold starts, and unit cost all become engineering decisions instead of vendor constraints.

That is the bet behind the open-source PaaS layer: the codegen race commoditizes writing code, so the durable advantage accrues to whoever operates the cheapest, most controllable runtime underneath it. Cursor, Lovable, and Replit are all walking down the stack toward that realization — from opposite ends, at different speeds.

Sources: Cursor Series D and ARR trajectory via SiliconANGLE (Nov 2025), Contrary Research, and industry revenue tracking; Lovable Series B, ARR milestones, and hosting mechanics via Reuters, Startup Fortune, and Lovable documentation; Replit Series D, ARR, and deployment types via Built In SF, TechCrunch/Bloomberg/Sacra coverage, and Replit documentation; Cursor Origin via announcements from August 2026.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Star the repo on GitHub or deploy your first app today.