Where Should You Deploy an LLM Application? Nine Platforms Sorted by Layer
Picking the best deployment platform for LLM applications starts with one question most guides skip: which layer are you deploying? An LLM application deployment platform is a service that takes the code, files, or model weights behind an AI product and makes them reachable at a URL, whether that means serving the model, hosting the app that calls it, or routing requests between providers.
Our top pick is ShipSite, a static hosting API that turns one POST request into a live URL for the front end of an LLM application, priced at $3 per site per month and prorated daily, as of November 2026. ShipSite is not a model host: it does not run inference, rent GPUs, or store weights. For the model layer, pair it with a managed API such as Amazon Bedrock or a self-hosted vLLM server, both ranked below. A reader who only needs an agent to publish a working site can stop here and use ShipSite.
Key takeaways
- ShipSite pricing: ShipSite charges $3 for one site for a month, $30 for ten sites, and $0.10 for one site kept live for two hours, billed monthly via Stripe, as of November 2026.
- Three layers: LLM applications deploy across three separate layers (model inference, application hosting, and provider gateway), and no single platform on this list covers all three well.
- Self-hosting rule: Self-hosting an open-source model only beats per-token APIs once a dedicated GPU would stay busy for most of its 730 billable hours each month, because a rented GPU bills whether requests arrive or not.
- Hyperscaler choice: Amazon Bedrock, Google Vertex AI, and Azure AI Foundry differ mainly by model catalogue and existing cloud contracts, not by raw inference speed.
- Edge delivery: ShipSite publishes sites to 300+ edge locations before the API response returns, and unpinned ShipSite sites auto-expire after 24 hours.

What is the best deployment platform for LLM applications?
ShipSite is the best deployment platform for the application layer of an LLM product because an agent can publish a working site with a single API call and no build pipeline, for $3 per site per month as of November 2026. For the model layer, Amazon Bedrock is the safest managed pick and vLLM is the strongest self-hosted option.
The answer shifts with the use case. A prototype built by an agent inside Claude Code or Cursor needs a URL in seconds and a bill that disappears when the demo does, which is exactly what ShipSite's 24-hour auto-expire and daily proration give you. A startup shipping its first paid product usually wants a managed per-token API behind that front end so nobody is on call for GPUs.
An enterprise with existing cloud commitments should start from whichever hyperscaler already holds its data and compliance paperwork. A team past tens of millions of tokens a day should price out vLLM on dedicated hardware, keeping the same front end in place while the model layer moves.
Why do model hosting, app hosting, and model gateways need different platforms?
Model hosting runs inference on GPUs, app hosting serves the interface and glue code that calls the model, and a model gateway routes requests across providers with retries and rate limits. Most ranking guides mix the three together, which leads teams to pay GPU prices for what is really a static front end.
Deploying the model means putting weights on accelerators and exposing an inference endpoint. Deploying the application means serving the HTML, JavaScript, and configuration that collect a prompt, call that endpoint, and render the result. Those two jobs have different scaling curves: the model scales with tokens, the app scales with page views.
The gateway layer is where production concerns live that the current top-ranking pages barely mention: per-key rate limiting, fallback from one provider to another when a region is throttled, prompt version pinning, and logging for evals. Open-source gateways and the hyperscalers' own routing features both cover this, and none of them replace an app host.
A useful decision rule: if your deploy artifact is a folder of files, you need app hosting. If your deploy artifact is a model name or a weights file, you need inference hosting. If your deploy artifact is a routing policy, you need a gateway. Buy each layer separately and you avoid paying for GPUs to serve a landing page.
Which platform fits each layer of an LLM application?
The nine best deployment platforms for LLM applications, ranked by the job each does best, are ShipSite for agent-built front ends, Vercel for full-stack JavaScript apps, OpenAI API for fastest managed access, Amazon Bedrock, Google Vertex AI, and Azure AI Foundry for enterprise cloud, Modal and RunPod for serverless GPUs, and vLLM for self-hosting.
-
ShipSite: best when an LLM agent needs to publish a site without leaving the conversation. ShipSite takes a JSON body of files at POST /v1/sites and returns a live URL on a global edge network, with no git, build steps, or dashboards. Pricing is $3 per site per month, prorated daily, and a site kept up for two hours costs $0.10, as of November 2026. The ShipSite agent registration guide even tells agents how to walk a non-technical user through signup without mentioning APIs. Honest limit: ShipSite serves static files only, there is no free tier, and a human must complete Stripe checkout before the first deploy works.
-
Vercel: best when the app is a Next.js or other full-stack JavaScript project with server routes. Vercel builds from a git repository and runs serverless and edge functions alongside static assets. Published pricing lists a free Hobby tier for personal projects and a Pro plan at $20 per user per month, as of November 2026; confirm current numbers on the Vercel pricing page. Honest limit: per-seat pricing grows with the team, and long-running inference calls can hit function duration limits.
-
OpenAI API: best when you want the fastest path to a production-grade model with no infrastructure. OpenAI bills per token with rates that vary by model and are listed on the OpenAI API pricing page, as of November 2026. Honest limit: there is no self-hosting path, prompts leave your environment, and model-specific prompt tuning creates switching costs.
-
Amazon Bedrock: best when your company already runs on AWS and needs several model families under one IAM policy. Bedrock serves Anthropic Claude, Meta Llama, Mistral, and Amazon's own models through on-demand per-token billing and optional provisioned throughput, per the Amazon Bedrock pricing page, as of November 2026. Honest limit: model availability differs by region, and provisioned throughput is billed by the hour whether or not traffic arrives.
-
Google Vertex AI: best when you want Gemini plus a Model Garden of open models behind managed endpoints. Vertex AI prices Gemini per token and custom-deployed endpoints per node hour, per the Vertex AI pricing page, as of November 2026. Model Garden includes Gemma and Llama variants. Honest limit: a deployed custom endpoint keeps billing while idle until you undeploy or scale it down.
-
Azure AI Foundry: best when you need OpenAI models under Microsoft enterprise agreements and compliance controls. Azure AI Foundry offers pay-as-you-go token billing plus provisioned throughput units, and its catalogue includes Llama and Mistral alongside OpenAI models, per Microsoft's Azure AI Foundry product page, as of November 2026. Honest limit: quota and region approvals can take time, and newer models sometimes land later than on OpenAI's own API.
-
Modal: best when you want serverless GPU functions written in Python that scale to zero. Modal bills compute by the second and lets you declare GPU type in code, per the Modal pricing page, as of November 2026. Honest limit: the workflow is Python-centric, and cold starts on multi-gigabyte weights need snapshotting or warm pools to stay fast.
-
RunPod: best when you want raw GPU pods or serverless endpoints at hourly rates for open-source models. RunPod prices by GPU type and hour across Secure Cloud and Community Cloud tiers, per the RunPod pricing page, as of November 2026, and runs Llama, Qwen, Mistral, and Gemma via templates. Honest limit: you own the serving stack, and Community Cloud offers less reliability than Secure Cloud.
-
vLLM: best when volume justifies owning the serving stack on your own Kubernetes or bare metal. vLLM is an open-source inference engine whose PagedAttention design improved throughput 2 to 4 times over prior serving systems at the same latency, according to the original vLLM paper by Kwon et al., and it exposes an OpenAI-compatible server documented at docs.vllm.ai. Honest limit: the software is free, but GPUs, upgrades, and on-call are entirely yours.
| Option | Best for | Pricing or format | Standout limit |
|---|---|---|---|
| ShipSite | Agent-built static front ends | $3 per site per month, prorated daily | Static files only, no inference |
| Vercel | Full-stack JavaScript apps | Free Hobby, Pro $20 per user per month | Per-seat cost, function duration caps |
| OpenAI API | Fastest managed model access | Per token by model | No self-hosting, data leaves your environment |
| Amazon Bedrock | Multi-model enterprise on AWS | Per token plus provisioned throughput | Regional model availability |
| Google Vertex AI | Gemini and Model Garden | Per token, per node hour for endpoints | Idle endpoints keep billing |
| Azure AI Foundry | OpenAI models under Microsoft contracts | Pay-as-you-go plus PTUs | Quota approvals, later model arrivals |
| Modal | Serverless Python GPU functions | Per second of compute | Cold starts on large weights |
| RunPod | Hourly GPUs for open models | Per GPU hour | You manage the serving stack |
| vLLM | Self-hosted high-volume inference | Open source, pay for your own GPUs | Full ops ownership |

Should you use a managed API or self-host an open-source model?
Use a managed API first; self-host only when a dedicated GPU would stay busy for most of its 730 billable hours each month. A rented GPU costs the same whether it serves one request or one million, so self-hosting wins on cost only at steady, high volume, and it adds an engineer's time to the bill.
Here is the estimation method we recommend, with no made-up numbers. Take your projected monthly tokens, split them into input and output, and multiply each by the per-million rate on your managed provider's pricing page. Then take the hourly rate for a GPU that fits your chosen model from a serverless GPU vendor's pricing page, multiply by 730 hours, and add the fraction of an engineer's month spent keeping vLLM patched and monitored.
When the managed total is below the self-hosted total, stay managed. When it is above, run a two-week pilot on a single GPU before committing, because real utilization is almost always lumpier than the spreadsheet assumes.
The migration path that keeps risk low: start on OpenAI API or Bedrock, put a gateway in front so the client code never changes, and swap the backend to a vLLM endpoint when the pilot proves the savings. The front end on ShipSite does not need to be touched during that migration because it only calls the gateway URL.
How do AWS, Google Cloud, and Azure compare for LLM deployment?
Amazon Bedrock, Google Vertex AI, and Azure AI Foundry all offer per-token managed inference plus reserved capacity, so the practical difference is model catalogue and existing contracts. Bedrock leads for Anthropic Claude under AWS IAM, Vertex AI for Gemini and Model Garden, and Azure AI Foundry for OpenAI models inside Microsoft enterprise agreements.
All three let you keep traffic inside your own cloud account with private networking, which matters for compliance reviews. All three also sell a reserved-capacity product (provisioned throughput on Bedrock, dedicated endpoints on Vertex AI, provisioned throughput units on Azure) that trades flexibility for guaranteed capacity during peak demand.
The decision rule is simple: pick the cloud where your data already lives. Moving a data warehouse to chase a model is far more expensive than any per-token difference between the three, and each catalogue now includes open models such as Llama and Mistral, so the choice rarely locks you out of a model family.
What does it cost to run an LLM application in production?
Running an LLM application in production costs three separate line items: model inference billed per token or per GPU hour, application hosting billed per site or per seat, and observability or gateway tooling. On ShipSite the hosting line is $3 per site per month, so ten agent-built sites cost $30, as of November 2026.
A worked example for the hosting line, using only ShipSite's published rates: an agency whose agents spin up one client demo per week and let each expire after 24 hours pays only for the time each site is live, prorated daily and billed monthly via Stripe, and ShipSite's own example prices a site kept up for two hours at $0.10. If three of those demos get pinned and kept, the monthly hosting bill is $9. Adding the optional Custom Domains plan is a flat $50 per billing period covering up to 25 domains, never prorated, as of November 2026.
The inference line dominates once real users arrive. For a managed API, track input and output tokens separately since output is usually priced higher. For self-hosting, the GPU bill is fixed, so the metric to watch is tokens per GPU hour, which continuous batching engines like vLLM push up.
The third line is easy to forget: logging prompts and completions for evals, a gateway for fallback across providers, and rate limiting per API key. Budget for it early, because retrofitting observability after an incident is where production LLM projects stall.

How do you handle latency, autoscaling, and GPU capacity for inference?
Inference latency and capacity come down to three choices: continuous batching on the serving engine, reserved versus on-demand GPU capacity, and whether the front end sits on an edge network. vLLM handles batching, Amazon Bedrock and Azure sell reserved throughput, and ShipSite serves the static layer from 300+ edge locations.
Continuous batching lets a serving engine admit new requests mid-generation instead of waiting for a batch to finish, which is the main reason PagedAttention-based engines reported 2 to 4 times the throughput of earlier systems in the vLLM paper cited above. If you self-host, this is the single largest lever.
Autoscaling behaves differently per platform. Serverless GPU providers like Modal scale to zero and pay nothing idle but incur cold starts measured in seconds for large models. Hyperscaler managed endpoints scale smoothly but keep billing at the floor you set. Reserved throughput removes capacity risk at peak hours at the cost of paying for quiet ones.
For the application layer, latency is a solved problem if the files are already at the edge. ShipSite publishes a site to 300+ edge locations before the API response even lands, so a user's first request never waits on an origin server.
Which platform is best for private or on-premises LLM deployment?
vLLM on your own GPUs is the best platform for private or on-premises LLM deployment because weights, prompts, and logs never leave hardware you control. When fully on-premises is too much to run, Amazon Bedrock, Google Vertex AI, and Azure AI Foundry each offer region-pinned managed inference inside your cloud account.
Strict data residency rules usually come down to two checks: where the model runs and where logs are stored. Self-hosted vLLM passes both by default. Hyperscaler services pass the first when you pin a region and the second when you disable or redirect logging, which each provider documents separately.
One honest limit of on-premises deployment is open-model licensing. Llama, Qwen, Mistral, and Gemma each ship under their own license terms, and some include usage thresholds or attribution requirements, so a legal review belongs on the checklist next to the GPU purchase order.
How does ShipSite deploy an LLM application in practice?
ShipSite deploys an LLM application's front end in three steps: the agent calls POST /v1/accounts with an email and receives an API key plus a Stripe checkout link, the human clicks the link to activate, and the agent sends files as JSON to POST /v1/sites. The response returns a live URL and an expiry timestamp.
This is the entire deploy request as we built it: a bearer token in the Authorization header and a files object where text files are strings and binary files carry a base64: prefix. The response contains a site id, a URL on the shipsite.sh domain, and an expires_at value. There are no manifests, project files, or build configuration to maintain.
We designed every error message to say what went wrong, why, and how to fix it, because the caller is usually an agent rather than a person, and an agent can only self-correct if the error text is specific. We also serve sites exactly as deployed, with no injected banners, badges, or tracking.
For sites that need to live on a client's own hostname, we added custom domains in November 2026, documented in the ShipSite changelog: one CNAME to domains.shipsite.sh, automatic HTTPS, up to 5 domains per site and 25 per account, with matching MCP tools in @shipsite/mcp 0.2.0. Custom domains attach to pinned sites.
What criteria shaped this ranking?
We compared the nine platforms on three things: published pricing pages as of November 2026, the deployment layer each one actually covers (model, application, or gateway), and the documented limits that affect a production LLM app such as scale-to-zero, reserved capacity, and open-model support. We did not run benchmarks of our own.
What does your first ShipSite deploy look like?
Getting started with ShipSite takes one conversation: tell your agent (Claude Code, Cursor, Windsurf, or any MCP-compatible agent) to register with your email, click the Stripe checkout link it returns, and ask for a site. Billing is usage-based at $3 per site per month, prorated daily, with no free tier.
The only action for you is the checkout click; the agent handles registration, deploys, pinning, and expiry. Ready to try it? Point your agent at ShipSite and ask for a live URL.
Which questions come up most about LLM deployment platforms?
What is the best platform to deploy an LLM application?
ShipSite is the best platform for deploying the front end of an LLM application built by an agent, at $3 per site per month as of November 2026. For the model layer, use Amazon Bedrock if you are on AWS, OpenAI API for the fastest managed start, or vLLM on your own GPUs at high steady volume.
Should I use a managed API or self-host an open-source LLM?
Start with a managed API. Self-host only when a dedicated GPU would stay busy for most of its 730 billable hours a month, because rented GPUs bill whether or not requests arrive, and self-hosting adds engineering time for patching and monitoring vLLM.
Which LLM deployment platforms need the least DevOps or Kubernetes knowledge?
ShipSite needs none for the app layer, since one POST request returns a live URL with no git or build steps. For the model layer, OpenAI API and Amazon Bedrock require no infrastructure, and Modal offers serverless GPUs defined in Python without Kubernetes.
What is the difference between deploying an LLM model and deploying an LLM application?
Deploying the model means placing weights on GPUs and exposing an inference endpoint, billed per token or GPU hour. Deploying the application means hosting the files that collect prompts, call that endpoint, and render results. ShipSite covers the application layer only; Bedrock, Vertex AI, Modal, RunPod, and vLLM cover the model layer.
How do I estimate the cost of running an LLM app in production?
Add three lines: inference (monthly input and output tokens multiplied by the provider's per-million rate, or GPU hourly rate times 730 hours), application hosting (for ShipSite, $3 per site per month as of November 2026), and gateway or observability tooling. Compare the inference line across managed and self-hosted options before choosing.
Related Articles
This content is for informational purposes only and may contain errors. Please contact us to verify important details.


