xhostd vs Lovable: flexible app hosting or a prompt-based builder

Lovable turns prompts into web apps and provides hosting, database, storage, and authentication through Lovable Cloud. xhostd hosts code built with your preferred AI coding agent, including always-on servers and background workers. Both offer an integrated backend. xhostd stands out when you need broader runtime choices, separate staging data, and predictable hosting costs.

What xhostd and Lovable both offer

Both xhostd and Lovable host web apps with an integrated backend and an MCP server that AI agents can use.

• Managed PostgreSQL with each app.
• Private file storage buckets.
• Managed Google sign-in with no OAuth client to create.
• Code you can reach through git.
• An MCP server that agents can use to change and publish an app.

The differences are in who writes the code, how backend code runs, and whether previews get their own data.

Key differences between xhostd and Lovable

Your own AI agent or Lovable's builder

xhostd: You keep working with Claude Code, Cursor, Codex, or any agent and model you like. Your code lives in your own git repository, and xhostd charges for hosting, not for AI usage.

Lovable: Lovable's builder writes the app from your prompts, and prompts use credits. Lovable's MCP server, on all plans, lets Claude Code, Cursor, and others create projects, read files and diffs, query the database, and publish. Changes made through it are prompts to Lovable's builder. The REST API needs Business or Enterprise.

Why it matters: Your agent and model are the tools you know best, and they keep improving. With xhostd your own agent writes the code, and you don't pay for building in credits.

Always-on servers or serverless functions

xhostd: Every app runs in an always-on container, on every plan, with no sleep mode and no cold starts. It runs Node.js, Python, or any Dockerfile, and long-running workers, bots, and queue consumers run the same way. Paid plans add public TCP.

Lovable: New projects use TanStack Start with server-side rendering, and backend logic runs as serverless Edge Functions. Scheduled jobs are available. Lovable documents no Python, Docker, always-on servers, long-running workers, or raw TCP.

Why it matters: A chat bot, a queue worker, or a long data job needs a process that keeps running. On xhostd it runs as part of your app; on Lovable it has to fit into functions and scheduled jobs.

Staging with its own data or one shared database

xhostd: Production, staging, and preview channels each have their own app, URL, files, and settings, and each code-running channel also has its own database. Nightly snapshots cover the database and files, kept 24 hours on Basic and 7 days on paid plans. Pre-deploy snapshots keep the last 1 on Basic and the last 3 on paid plans.

Lovable: Lovable retired its separate Test and Live databases on October 5, 2026. Drafts now preview code only and share the one live database. Version history reverts code but not data. The database gets a daily backup kept about 14 days, with no point-in-time recovery, and backups exclude stored files.

Why it matters: On Lovable, a draft reads and writes the same live database your users do. On xhostd you try the change on staging first, and you can restore data from before a deploy.

One known price or one shared credit balance

xhostd: Fixed monthly plans: free, then $10, $20, $40, or $80. For example, the $10 Builder plan includes 10 channels, 1 GB of memory, 10 GB of database storage, and 50 GB of file storage. There are no traffic, egress, or seat charges.

Lovable: Pro starts at $25 a month ($21 billed yearly), and Business starts at $50 a month ($42 billed yearly). One credit balance covers building, Cloud hosting, and in-app AI. Cloud bills database server and storage, file storage, network, compute, and realtime as "Run" credits.

Why it matters: On Lovable, building more and serving more users draw on the same credits. With xhostd, a busy month doesn't change the bill.

Compute and runtime

xhostd: Each channel runs in an always-on container, on every plan, with no sleep mode and no cold starts. You can run a static site on nginx, an app on a template with Node.js 22, Python 3.13, and uv, or your own Dockerfile. CPU is a guaranteed share that can burst to 2x, from 0.1 core on Basic to 4 cores on Pro, and memory is an account total from 128 MB to 8 GB. A process has no run time limit, so workers, bots, and queue consumers keep running.

Lovable: Since May 13, 2026, new Lovable projects use TanStack Start with server-side rendering. Backend logic runs as serverless Edge Functions, and scheduled jobs handle timed work. Python, Docker, always-on servers, long-running workers, and raw TCP are not documented. Edge Function time and memory limits are also not documented.

Summary: Both run server-side code for a web app. The difference: xhostd runs always-on containers with no time limit, including Python and your own Dockerfile, while Lovable runs backend logic in Edge Functions and scheduled jobs.

Deploys and AI agents

xhostd: Every app has its own git repository. A push stores the code, and a deploy publishes a chosen branch or commit; GitHub-connected apps can also deploy on each push. Every deploy passes a health check before a blue-green switch, and a failed deploy leaves the previous version serving. Agents work through a hosted MCP server, an HTTP API with an OpenAPI spec, and plugins for Claude Code and Codex.

Lovable: Lovable's builder writes and publishes the app from prompts, and each prompt uses credits. Its MCP server at mcp.lovable.dev, on all plans, lets external agents prompt the builder, read files and diffs, query the database, and publish. Two-way git sync supports editing outside Lovable, and code download is available. The REST API comes with Business and Enterprise.

Summary: Both offer an MCP server and git access to the code. The difference: xhostd deploys a chosen branch or commit that your own agent pushed, while Lovable's MCP server sends changes as prompts to its builder.

Database

xhostd: Every code-running channel gets its own PostgreSQL database, included in the plan. Your app receives a main connection, a direct connection for migrations, and a read-only connection; on newer database servers the main connection is pooled through PgBouncer in transaction mode. PostGIS is available. Database storage is an account total across all your apps and channels, from 500 MB on Basic to 80 GB on Pro, as a soft limit: xhostd reaches out instead of stopping your app.

Lovable: Lovable Cloud runs PostgreSQL on Supabase, with instance sizes from Tiny to X-Large and storage from 8 GB. You can connect your own Supabase project instead, but a move from Cloud to your own Supabase is an export and a rebuild. A database export can run once every 24 hours, for databases up to 15 GB, as a file of up to 5 GB. It leaves out files, functions, and secrets.

Summary: Both include managed PostgreSQL. The difference: xhostd includes a database in every code-running channel within the plan, while Lovable Cloud runs it on Supabase, bills it in credits, and lets you bring your own Supabase project.

File storage

xhostd: Each channel gets its own S3-compatible bucket, so standard S3 libraries work. Versioning is always on, and old versions and deleted files are kept for 120 days. File storage is an account total across all your apps and channels, from 2 GB on Basic to 400 GB on Pro, as a hard limit. Files are served through your app; there are no public object URLs.

Lovable: Lovable Cloud storage buckets are private, and row-level security policies control access. Uploads are limited to 2 GB by default and can go up to 5 GB. Database backups and data exports leave stored files out, and S3 compatibility is not documented.

Summary: Both keep app files in private buckets. The difference: xhostd buckets are S3-compatible and keep old versions for 120 days, while Lovable buckets use access policies and stay out of backups and exports.

Environments and previews

xhostd: Production, staging, and previews are separate channels. Each channel is its own container with its own URL, file bucket, environment overrides, up to 5 custom domains and, for code-running apps, its own PostgreSQL database. A new preview starts with an empty database, so tests never touch production data. Channels come from one account-wide pool: 3 on the free plans, then 10, 20, 40, or 80.

Lovable: Since October 5, 2026, drafts share the live database: Lovable retired its separate Test and Live databases on that date. A draft previews code changes, and there is no separate staging database.

Summary: Both let you preview a change before you publish it. The difference: xhostd gives each preview its own empty database, while Lovable drafts share the live database.

User sign-in

xhostd: Google sign-in is built into every channel and custom domain, on every plan, with no OAuth app to create. After sign-in, your app receives a signed token with the user's ID, email, and name, and verifies it against xhostd's public keys. Your app decides which pages need sign-in.

Lovable: Sign-in options include email and password, phone through your own SMS provider, Google, Apple, Microsoft, and Security Assertion Markup Language (SAML) single sign-on (SSO). Managed Google sign-in needs no OAuth client of your own.

Summary: Both offer managed Google sign-in with no OAuth app to create. The difference: xhostd's built-in sign-in is Google, while Lovable also offers email, phone, Apple, Microsoft, and SAML SSO.

Backups and recovery

xhostd: Nightly snapshots cover the database and files, and xhostd also takes a snapshot before each deploy. Free plans keep 24 hours of nightly snapshots and the last pre-deploy snapshot; paid plans keep 7 days and the last 3. A restore can run read-only, behind a maintenance page, or live, and a code rollback boots the previous image without a rebuild. xhostd restores to these snapshots, not to any chosen moment.

Lovable: Lovable takes a daily database backup and keeps it about 14 days. Stored files are not in the backup, and there is no point-in-time recovery. Version history rolls back code only, not data.

Summary: Both back up the database daily, and neither restores to any chosen moment. The difference: xhostd snapshots files too and takes a snapshot before each deploy, while Lovable keeps database backups for about 14 days and leaves files out.

Networking and domains

xhostd: Every channel gets an HTTPS address, and each channel can add up to 5 custom domains with automatic certificates, on every plan. Paid plans add one public TCP endpoint per channel, with an optional IP allowlist.

Lovable: Apps get a hosted address. Custom domains need a paid plan. Raw TCP, region choice, and CDN options are not documented.

Summary: Both give apps a hosted address and support custom domains. The difference: xhostd includes custom domains on every plan and adds public TCP on paid plans, while Lovable custom domains need a paid plan.

Logs and monitoring

xhostd: You get deploy and runtime logs, including logs from earlier containers, plus health findings with latency percentiles (p50, p95, and p99) and resource readings. Visitor analytics show visits, unique visitors, top pages, broken links, and status codes, without adding a script to your pages.

Lovable: Lovable provides traffic analytics, backend logs, and database health tools. Security checks and configurable approvals for database changes are also available. Log retention is not documented.

Summary: Both provide logs and traffic analytics. The difference: xhostd adds latency percentiles and resource readings, while Lovable adds database health tools and security checks.

xhostd and Lovable pricing

xhostd: Fixed monthly plans: Basic free, Builder $10, Indie $20, Studio $40, and Pro $80. For example, Builder includes 10 channels, 0.5 CPU core, 1 GB of memory, 10 GB of database storage, and 50 GB of file storage. Hosting, PostgreSQL, storage, and backups are included, with no traffic, egress, or seat charges; xhostd might throttle disproportionate traffic after contacting you. See xhostd plans.

Lovable: The free plan gives 5 build credits a day, up to 30 a month, plus 20 Cloud credits and 4 AI credits. Paid plans start at $25 a month for Pro ($21 billed yearly) and $50 a month for Business ($42 billed yearly). Building, Cloud hosting, and in-app AI draw on one credit balance. Cloud bills database server and storage, file storage, network, compute, and realtime as "Run" credits. Workspaces have unlimited members with no seat fee.

Summary: Both have a free plan and no seat fees. The difference: xhostd charges a fixed monthly price with no traffic or egress charges, while Lovable draws building and hosting from one credit balance and meters Cloud usage in credits.

Price example: On xhostd, a small always-on app with PostgreSQL and file storage costs $0 on the free Basic plan (0.1 CPU core, 128 MB of memory), or $10 a month on Builder (0.5 core, 1 GB). On Lovable, the Free plan includes build and Cloud credits, but a custom domain needs a paid plan, from $25 a month on Pro ($21 billed yearly), and hosting draws on credits. For hosting with a custom domain, xhostd costs less: custom domains come with every xhostd plan, the free plan included.

Where xhostd is a better fit

xhostd is the stronger choice when:

• You build with Claude Code, Cursor, or Codex and want your agent to deploy a branch or commit it pushed. xhostd deploys the chosen branch or commit, while changes through Lovable's MCP server go to Lovable's builder as prompts, and prompts use credits.
• You need Python, a Dockerfile, or a worker that keeps running. xhostd runs always-on containers, while Lovable runs backend logic in Edge Functions and scheduled jobs and doesn't document Python or Docker.
• You want to try changes on staging before your users see them. Each code-running xhostd channel has its own database, and a snapshot before each deploy covers the database and files. Lovable drafts share the one live database.
• You want hosting costs that don't depend on how much you build. xhostd charges a fixed plan price, while Lovable draws building, Cloud hosting, and in-app AI from one credit balance.

Where Lovable is a better fit

Consider Lovable if you want:

• One builder for everything. Lovable writes, previews, and publishes the app from your prompts. xhostd doesn't require you to write code either, but you need to be familiar with a coding agent such as Claude Code, Cursor, or Codex.
• More built-in sign-in options. Besides Google, Lovable supports email and password, Apple, Microsoft, SAML SSO, and phone sign-in. xhostd's built-in sign-in is Google.
• AI building included. Lovable's free plan includes 5 build credits a day, up to 30 a month. xhostd works with the coding agent you already have.
• A database server size you choose. Lovable Cloud lets you pick the database instance, from Tiny to X-Large. On xhostd, database storage grows with the plan.

xhostd vs Lovable at a glance

	xhostd	Lovable
Compute model	Always-on containers	Server-rendered app plus Edge Functions
Sleep and cold starts	None, on every plan	Not documented
Run time limit	None	Not documented
Languages and Docker	Node.js, Python, any Dockerfile	TanStack Start; Docker not documented
Database	PostgreSQL in every code-running channel, included	Cloud PostgreSQL on Supabase, in credits
File storage	S3-compatible bucket per channel, included	Private buckets, uploads to 5 GB
Previews with their own data	Yes, every channel	No; drafts share live database
Point-in-time recovery	No; nightly and pre-deploy snapshots	No; daily backups, about 14 days
AI agent access	Hosted MCP server, API, plugins	MCP prompts builder; API on Business
Pricing model	Fixed plans, $0 to $80	Credits; Pro from $25