VUE HOSTINGDEPENDENCIES, CONNECTED.

Change state.
Everything
follows.

Build with Vue’s reactive model. Ship a focused frontend, or choose a Nuxt runtime for the routes that need a server.

Explore Vue hostingVue + Vite / Vue Router / Nuxt
reactivity.devtoolsLOCAL MODEL
SOURCE STATEconst concurrency = ref(3)
3
COMPUTED VALUEworkers.slice(0, concurrency)
worker_1worker_2worker_3worker_4worker_5worker_6

3 selected / 6 example workers

DERIVED UI3 workers selected · 3 available
Explore reactive dependencies. No workers are started.
STATE → DERIVATION → VIEW

One source of truth.
Fewer moving parts.

Derive values instead of maintaining duplicate state. Keep side effects intentional and network operations explicit.

ref()

Store the input.

Use reactive state for values the user changes. Keep each state owner clear as the application grows.

computed()

Derive the result.

Use a computed value for data that follows from state. Filtered lists and totals should follow the same source.

watch()

Handle the effect.

Use watchers for effects such as fetching data. Handle cancellation and errors when inputs change during a request.

Vue computed properties ↗
CHOOSE THE EXECUTION MODEL

Same Vue.
Different outputs.

Rendering decisions determine deployment requirements. Inspect the build output before choosing a target.

BROWSER APPLICATION

Vue + Vite

npm run build→ dist/
Rendering
Browser-driven interface
Data
Protected external API
Navigation
Vue Router + history fallback

Test a direct request to a nested route. Public frontend variables must contain no secrets.

Vue production deployment ↗
FRAMEWORK APPLICATION

Nuxt

rendering mode→ Nitro preset
Static generation
Generated public assets
Request-time rendering
Compatible runtime required
Private operations
Server routes + runtime config

Review the Nitro target for server features. Container compute is billed separately from edge and build allowances.

Nuxt rendering modes ↗
GOOD IDEAS DESERVE A START

Reactive interfaces. Predictable plan allowances.

Free, Pro, and Team. Shared hosting allowances, GitHub + MCP deployment, and a global CDN. Choose the resources your project needs.

50% off · every renewal, too
Your first big idea

Free

Start building. Put something real on the web.

$0/ month

No base plan charge

Free to start. No upfront plan charge.
Commercial projects welcome.

Start building free
Requests
1M
Bandwidth
100 GB
Edge CPU time
10M ms
Build minutes
100
Team members
Solo
Default usage budget
$0 · hard stop
  • AI website builder included
  • 5,000+ themes to start from
  • Commercial use allowed
  • No per-seat charges
  • GitHub + MCP deployment
  • Global CDN + DDoS protection
Make room for everyone

Team

Shared projects. More resources. Unlimited members.

$12.50/ month$25

Save $600 · regular 48-month total $1,200

$600 paid upfront for 48 months.
Renews at $600 / 48 months.

Choose Team
Requests
25M
Bandwidth
2.5 TB
Edge CPU time
250M ms
Build minutes
1,250
Team members
Unlimited
Default usage budget
$100
  • AI website builder included
  • 5,000+ themes to start from
  • Commercial use allowed
  • No per-seat charges
  • GitHub + MCP deployment
  • Global CDN + DDoS protection

USD, before tax. Resource allowances reset monthly. Monthly equivalents are rounded for display; the upfront total is exact. Term discounts apply at every renewal. The 48-month term includes 24 free months.

Paid-plan usage budgets cover on-demand usage beyond included resources and add-ons; they exclude the base plan charge. Pro defaults to $50; Team to $100. Budget controls are not an instant hard-stop guarantee. Free has a $0 hard stop. These plans include edge and build allowances. Container compute and database services are metered separately.

Compare every plan inclusion
App hosting plans · included resources
Your plan, in detailFreeProTeam
Monthly equivalent$0$7$12.50
Upfront plan total$0$336$600
Renewal total$0 / 48 months$336 / 48 months$600 / 48 months
Requests1M10M25M
Bandwidth100 GB1 TB2.5 TB
Edge CPU time10M ms100M ms250M ms
Build minutes1005001,250
Team membersSoloUp to 3Unlimited
Default usage budget$0 · hard stop$50$100
Commercial useIncludedIncludedIncluded
No per-seat chargesIncludedIncludedIncluded
AI website builderIncludedIncludedIncluded
5,000+ themesIncludedIncludedIncluded
GitHub integrationIncludedIncludedIncluded
MCP integrationIncludedIncludedIncluded
Global CDNIncludedIncludedIncluded
DDoS protectionIncludedIncludedIncluded

VUE SPA OR NUXT SERVER

Choose where the
first render happens.

Deploy a Vue SPA or choose a compatible server target for Nuxt.

Public catalog

Pre-render public content for CDN delivery.

Customer workspace

Keep personalized routes on a server-capable runtime.

Browser dashboard

Add backend services for forms and durable data.

Technical details

A Vue interface and a Nuxt application share a component ecosystem, but they can ask different things of hosting. Decide whether a route is a static page, a browser application or a response built for the current visitor before choosing its deployment target.

Public catalog

Pre-render content that can be known at build time and deliver the generated files through the CDN. Keep the update process clear when prices or editorial content change. Static generation trades request-time work for build-time work.

Customer workspace

Use a compatible Nuxt server target when a page needs request-specific server data. Verify the Nitro deployment preset and runtime dependencies. A full Node server belongs on compatible container compute, which is metered separately.

Browser dashboard

A Vue SPA can call a private backend API for account records. Configure direct navigation for client routes and handle API failures explicitly. Never turn an API error into the app’s successful HTML fallback response.

RUNTIME CONFIGURATION

Public means public.
Keep secrets server-side.

Keep production credentials behind the server boundary.

Name the boundary

Keep private values out of public configuration.

Connect persistent data

Connect application services through private resource references.

nuxt.config.ts · configuration shape
export default defineNuxtConfig({
  runtimeConfig: {
    serviceApiKey: "",
    public: {
      apiBase: "/api"
    }
  }
});
Illustrative source · adapt to your application
Technical details

Nuxt separates public runtime configuration from private server values. Use that distinction deliberately. A configuration value that reaches rendered page data or the client bundle is visible to the visitor, even if its original source was an environment variable.

Name the boundary

Expose a public API base path only when the browser needs it. Keep credentials in private runtime configuration and sealed deployment secrets. Audit composables and server responses for accidental serialization of configuration objects.

Connect persistent data

Use managed Postgres from a compatible server runtime for users and business records. Prefer pooled application connections, and reserve direct connections for migrations. Daily backups support recovery; HA and point-in-time restore depend on your database plan.

Supply the private value through server configuration; never put it in public.

Nuxt runtime configuration

CONSISTENT RENDERING

Make the second render
agree with the first.

Coordinate the first render, cached reads and persistent updates.

  1. Make initial data deliberate

    Use framework data fetching for SSR and hydration.

  2. Cache shared reads carefully

    Scope cached reads by account and freshness.

  3. Give mutations a durable path

    Validate mutations and queue slower side effects.

Database and container resources are metered separately.

Technical details

When Nuxt renders HTML on the server, the browser takes over a page that already exists. Keep the initial result consistent, then add browser-dependent behavior at the right time. Test with slow connections and expired sessions as well as your own warm development cache.

Make initial data deliberate

Use the framework’s data-fetching conventions for SSR and hydration. Avoid independently fetching the same initial record in several components. Keep browser-only state, such as local storage, out of assumptions used to generate server HTML.

Cache shared reads carefully

Valkey can support suitable shared caches and short-lived state behind the server. Include the right account and freshness boundaries in cache keys. Do not reuse a personalized response simply because two requests share a URL.

Give mutations a durable path

Validate form submissions on the backend and queue longer imports or notifications. Show a clear success or failure state in Vue. Monitor server response time separately from client rendering and database waits before increasing capacity.

Let.com × VERCEL / COST MODEL

A team budget for your Vue frontend.

Choose a monthly workload and purchase term. See the included capacity, team seats and modeled delivery costs together.

3 deploying members5M requests / month500 GB transfer / month400 build minutes / month

Static delivery + builds. Commercial use. Zero server compute in this example.

Explore all plans ↗
Let.com Pro$7/mo

$336 paid upfront for 48 months. Same-term renewal: $336.

Deploying members
No seat charge
Delivery + builds shown
Within plan limits
Vercel Pro · modeled$62.80–$80/mo

$3,014.40–$3,840 over 48 months, billed monthly. Constant usage and today’s rates.

Deploying seats
$60/mo
Flat Rate CDN tier
$20/mo
Basic builds, before credit
$2.80/mo
Monthly usage credit
Up to −$20
$2,678.40 less over 48 monthsCompared with the lower Vercel estimate, for only the services modeled above.
How this comparison works + sources

USD before tax. Monthly requests are CDN asset requests, not unique people or page views; GB uses decimal units. Vercel is modeled with Flat Rate CDN enabled for an eligible web application and Basic 2-vCPU builds at $0.007 per minute. Build times are equal in the example, not a performance benchmark. Viewer seats are free on Vercel; the count above is deploying members.

The range reflects unclear credit eligibility for the fixed CDN tier: the lower estimate lets the $20 credit offset CDN plus builds; the upper applies it to builds only. Savings use the lower estimate. Actual invoices depend on configuration. This is a selected Flat Rate CDN configuration, not a claim that it is Vercel’s cheapest possible setup.

Excluded on both sides: server/edge execution, database and container compute, image processing, storage, model/API fees, add-ons and taxes. Let.com’s Edge CPU allowance cannot be equated directly to Vercel’s Fluid Compute CPU and memory billing. Workloads beyond Let.com inclusions are deliberately unpriced here. Multi-year totals assume constant usage and current prices; Vercel is billed monthly, not sold as a four-year commitment.

Rates reviewed October 20, 2026: Vercel Pro + seats · Flat Rate CDN · Basic build rates. Let.com rates come from the plans on this page.

Brand portfolio · planned deployments

Different businesses.
One flexible foundation.

Architecture examples for brands in our portfolio. These are planned deployments, not completed migrations or measured case studies.

Let.com

Hosting operations, working together.

Let.com is preparing web hosting, WordPress hosting and domains. A planned Let.com operations backend would track provisioning in managed PostgreSQL and process setup tasks through a queue, with Valkey for short-lived status.

  • Backend
  • PostgreSQL
  • Queue
  • Valkey
Explore backend hosting
Audit.com

Keep assessment work moving.

Audit.com offers security assessments, readiness services and remediation engineering. The proposed Let.com workspace would use managed PostgreSQL for engagement tracking, queued report jobs and asset storage for project files.

  • Backend
  • PostgreSQL
  • Queue
  • Assets
Explore app hosting
Document.com

From questionnaire to finished document.

Document.com combines guided templates, document storage and e-signatures. A planned Let.com backend would keep workflow records in managed PostgreSQL and send document generation to a queue, with files in asset storage.

  • Backend
  • PostgreSQL
  • Queue
  • Assets
Explore app hosting
REFERENCE / VUE

Before deployment.

Framework decisions that change what you ship.

Can I deploy an existing create-vue project?

Yes. Confirm its Vite build command and output directory, then publish production assets. Test API requests and Vue Router behavior after deployment.

Does Vue Router need a Node.js process?

A typical static SPA does not need Node.js at request time. HTML5 history mode does need suitable host fallback rules for direct visits. Server rendering has separate runtime requirements.

Does changing concurrency start real workers?

No. This page models a reactive dependency using local browser state. The controls change a displayed selection only; they do not allocate compute or call an API.

When should I choose Nuxt?

Consider Nuxt when you want framework-managed routing, generated pages, request-time rendering, or server endpoints. Its rendering mode and runtime target determine the deployment.

How do I keep runtime configuration private?

Frontend bundle values are public. In Nuxt, review which runtime configuration is public and which stays server-side; do not return private configuration through page data or API responses.

State changes. Your foundation holds.

Deploy your Vue frontend with the rendering model it needs.

Compare hosting plans

Let.com

Coming soon.

Account sign-up, log-in and checkout are not available yet. You can explore our products and compare plans while we get everything ready.

Compare plans