DEV Community: HostingSift

Vercel AI SDK Alternatives and Where to Host Them in 2026

HostingSift — Mon, 21 Sep 2026 08:30:22 +0000

Updated 21 September 2026. Hetzner raised its cloud prices on 15 June 2026, and the shared CX plans this guide first recommended are not in its current price list. Every VPS price below was re-checked on the providers' own pages on 21 September 2026. Hetzner lists prices excluding VAT, with the primary IPv4 address billed separately at €0.50. netcup lists prices including 19% German VAT, with IPv4 included.

Vercel AI SDK is great. It is also locked to a specific philosophy of how AI apps should be built, and it strongly incentivizes you to host on Vercel where you will quickly discover that real AI workloads run into Vercel's pricing in unhappy ways. A $20 Vercel bill becomes a $200 bill the first month an agent loop runs hot.

If you are looking at alternatives, you are not alone. The AI framework ecosystem in 2026 has more credible options than at any point since LangChain shipped. Some are better for agents. Some are better for type safety. Some give you the AI SDK ergonomics without the Vercel gravity well. And the hosting decision for each is different.

This is a working engineer's tour of the alternatives, where they shine, and where to actually deploy them without burning money.

What Vercel AI SDK does well, and where it forces your hand

The good parts: streaming responses out of the box, clean React hooks (useChat, useCompletion), a unified provider abstraction so swapping OpenAI for Anthropic is a one-line change. Tool calling is well-designed. The TypeScript types are tight.

The friction: the SDK assumes Next.js as the primary host. Server actions and route handlers are the recommended patterns. The moment you want to host the backend somewhere other than Vercel, you start fighting the framework. Vercel Functions also enforce a hard maximum duration. With Fluid compute, which is on by default, Hobby functions stop at 5 minutes. Pro functions can be configured up to 800 seconds, or 30 minutes with the extended-duration beta. That is plenty for a chat reply and tight for an agent that works through a long task list. Long-running agent loops need workarounds (background jobs, queue-and-poll patterns) that erase the simplicity argument.

Pricing is the second issue. Vercel charges by function invocation, GB-hours, and bandwidth. AI streaming chews bandwidth. Agent loops chew invocations. The pricing model that works beautifully for a marketing site quickly stops working for a chatbot with a thousand daily users.

The alternatives worth considering

Mastra (TypeScript-first agent framework)

Mastra is the most direct AI SDK competitor that emerged in 2024-2025. Built by the Gatsby founders. Pure TypeScript, designed for agents from day one. Workflows are first-class. Memory and RAG are built in. Deploy targets include Cloudflare Workers, Vercel, AWS Lambda, and any Node-compatible host.

What you get:

Step-based workflow engine with retries, branching, parallelization.
First-class memory (Postgres, Pinecone, in-memory, all swappable).
Tool definitions with Zod schemas, type-checked end to end.
Built-in eval framework for grading agent outputs.
Deploy command targets Cloudflare, Vercel, Netlify, or self-hosted Node.

Best deploy target for Mastra: Cloudflare Workers if your agents are short-lived, a small VPS if they run long or need persistent state. A netcup VPS 500 G12 (2 vCores, 4 GB RAM) at €5.91 per month runs production Mastra agents fine.

LangChain and LangGraph

LangChain is the obvious one. In 2026 the conversation has shifted to LangGraph as the recommended LangChain entry point for new projects, especially for agents. LangGraph treats agent runs as state machines, which makes complex flows tractable and debuggable.

The frame here is different from the AI SDK. LangChain is a Python-first framework with a TypeScript port that is always one version behind. If your team is Python-native, LangChain or LangGraph plus LangSmith for observability is a strong stack. If your team is TypeScript-native, Mastra is usually a better fit and Vercel AI SDK is competitive too.

Deploy target: LangGraph has its own Cloud hosting product (LangGraph Cloud), or you self-host the runtime on any Python-capable VPS. For self-hosting, a 4 GB VPS handles most workloads. The netcup VPS 500 G12 (4 GB) at €5.91 or a DigitalOcean Basic droplet with 2 GB at $12 are both fine starting points.

LlamaIndex

The strongest framework if your problem is "I have a lot of documents and I need agents that answer questions over them." LlamaIndex started as a RAG-first toolkit and grew into a general agent framework while keeping that document-heavy DNA.

If you are building a knowledge worker assistant, internal-docs Q&A, customer support over a help center, LlamaIndex usually beats the alternatives because the ingestion, chunking, and retrieval primitives are more thoughtful.

Deploy target: any Python host. LlamaIndex itself is light. The expensive part is the vector store, which dictates your real hosting choice. If you use Postgres pgvector, your Postgres instance is the bottleneck. If you use Pinecone or Qdrant, your bill is in the vector DB.

PydanticAI

The newest credible entrant. Built by the Pydantic team. Heavy emphasis on type safety, model-agnostic abstraction, and structured outputs. If you already use Pydantic for validation (and most Python AI teams do), PydanticAI fits naturally.

What is notable: PydanticAI was designed after the lessons from LangChain. It is smaller, less opinionated, easier to read. The tradeoff is that it provides fewer batteries-included features. You bring your own memory, your own retrieval, your own observability. Many teams prefer this.

Deploy target: any Python host. Small footprint. A 2 GB VPS at $6/month or less is more than enough for most projects. Our VPS price comparison lists the current options.

OpenAI Agents SDK

OpenAI released their own agents framework in 2025. It is well-designed if you are exclusively on OpenAI models. It supports handoffs between agents, structured tool use, and tracing through OpenAI's observability dashboard. The tradeoff is obvious: deeper OpenAI lock-in.

If you are committed to GPT models long term, the Agents SDK is the path of least resistance. If you want flexibility to swap to Claude, Gemini, DeepSeek, or self-hosted models, look elsewhere.

Anthropic SDK directly (no framework)

Worth saying out loud: a lot of teams who started with a framework end up dropping it and calling the model SDK directly. The Anthropic SDK and OpenAI SDK are both small, well-documented, and stable. If your app is a single agent loop with a handful of tools, framework overhead can hurt more than help.

The Anthropic SDK in particular handles tool use, streaming, and parallel calls with a clean API. Combined with Hono or Elysia for the HTTP layer, you can ship production AI features with fewer dependencies than the AI SDK pulls in.

Deploy target: anywhere. Hono runs on Bun, Node, Cloudflare Workers, Deno, AWS Lambda. The same code deploys to all of them. We use this exact pattern at HostingSift.

Side-by-side: when each one wins

Framework	Language	Best for	Hosting fit	Lock-in
Vercel AI SDK	TypeScript	Next.js chat UIs	Vercel (others possible but painful)	High to Vercel patterns
Mastra	TypeScript	Agents with workflows	Anywhere Node runs	Low
LangGraph	Python (TS port)	Complex agent graphs	LangGraph Cloud or self-host	Medium
LlamaIndex	Python	RAG-heavy applications	Any Python host	Low
PydanticAI	Python	Type-safe minimalist agents	Any Python host	Low
OpenAI Agents SDK	Python and TS	OpenAI-committed teams	Anywhere	High to OpenAI
Direct SDK + Hono	TypeScript	Custom architecture	Anywhere	Minimal

Where to host the backend, by use case

The VPS picks in this section changed after Hetzner's June 2026 repricing. Here is what the plans mentioned below cost on 21 September 2026, as each provider lists them.

Plan	CPU	RAM	Price per month	Billing
netcup VPS 500 G12	2 vCores	4 GB	€5.91 incl. VAT	12-month term; €6.81 without a term
netcup RS 1000 G12	4 dedicated cores	8 GB	€12.79 incl. VAT	12-month minimum
netcup VPS 2000 G12	8 vCores	16 GB	€19.25 incl. VAT	12-month term
netcup RS 2000 G12	8 dedicated cores	16 GB	€21.43 incl. VAT	12-month minimum
Hetzner CPX22	2 vCPUs	4 GB	€19.49 excl. VAT	Hourly, no minimum
Hetzner CCX13	2 dedicated vCPUs	8 GB	€42.99 excl. VAT	Hourly, no minimum
Hetzner CPX42	8 vCPUs	16 GB	€69.49 excl. VAT	Hourly, no minimum
Hetzner CCX23	4 dedicated vCPUs	16 GB	€85.99 excl. VAT	Hourly, no minimum
Vultr Cloud Compute	1 vCPU	1 GB	$6	Hourly, no minimum
DigitalOcean Basic	1 vCPU	1 GB	$6	Hourly, no minimum

The trade-off is commitment. netcup is far cheaper per core and per GB, but its regular prices assume a 12-month contract. Hetzner, Vultr and DigitalOcean bill by the hour, which matters when you are still experimenting and may tear the server down next week.

Chat UI with streaming, low to medium traffic

Cloudflare Workers is the right answer for most teams. Long-running streams work. Global edge means low latency. The free tier covers a surprising amount of traffic, and the $5 paid tier covers an unsurprising amount. Mastra, PydanticAI (via Pyodide-Workers patterns), and Hono with the Anthropic SDK all deploy here cleanly.

If you need persistent server-side state across requests, drop down to a VPS. netcup VPS 500 G12 at €5.91, Vultr Cloud Compute at $6, or DigitalOcean Basic at $6 all work. Pair with Caddy for TLS and you have a streaming-capable backend for about 6 EUR or 6 USD per month.

Agent loops with long runs

Stay away from anything with a hard duration cap you cannot raise. Vercel Hobby stops at 5 minutes. Vercel Pro reaches 800 seconds, or 30 minutes in beta, which covers many agent runs but not open-ended ones. Most Lambda configurations are out unless you split into step functions.

What works: PaaS platforms that run long-lived processes (Railway, Render), or a self-hosted VPS. Railway lets you run a long-lived process for $5-10/month. For dedicated cores, the netcup RS 1000 G12 gives you 4 dedicated AMD EPYC 9645 cores and 8 GB of DDR5 for €12.79 per month, on a 12-month minimum term. If you need hourly billing instead, Hetzner's CCX13 with 2 dedicated vCPUs and 8 GB costs €42.99 per month.

For background agent jobs that take minutes or hours, queue them. BullMQ on Redis, a SQS-equivalent, or a Postgres-backed job runner like Inngest. Trigger from your API, process on a worker process. The worker can live on the same VPS.

RAG with vector search

Your hosting bill is dominated by the vector DB, not the application server. Three reasonable approaches:

Postgres pgvector on a beefy VPS. Self-hosted, full control, runs on the same box as your app. A netcup VPS 2000 G12 with 8 vCores and 16 GB RAM at €19.25 handles millions of vectors. Hetzner's nearest orderable shared plan, the CPX42, costs €69.49.
Qdrant or Weaviate self-hosted. Same hosting math. Slightly better query performance for very large indexes.
Managed vector DB (Pinecone, Qdrant Cloud, Turbopuffer). Trade $50-200/month for zero ops.

Most apps with under 5 million chunks should self-host pgvector and move on. Above that, managed services start paying for themselves.

High-traffic AI features for B2B SaaS

If you are doing tens of thousands of AI calls per day for paying customers, neither Vercel nor Cloudflare Workers makes sense long-term. The pricing models are designed for variable traffic. Predictable high traffic is cheaper on dedicated resources.

A netcup RS 2000 G12 (8 dedicated AMD EPYC cores, 16 GB RAM) at €21.43 per month runs a production AI backend with significant headroom. The hourly-billed alternative is Hetzner's CCX23 with 4 dedicated vCPUs and 16 GB at €85.99. Add Cloudflare in front for caching and rate limiting (free tier). On the netcup box you spend under 30 EUR per month for what would be $300+ on serverless.

The catch is ops. You patch the VPS. You configure Caddy. You set up Postgres backups. Two days of upfront work, then it runs.

Edge inference with small models

The 2025-2026 development worth mentioning. Cloudflare Workers AI, Vercel's AI Gateway, and Bun's local model loading have made it realistic to run small models (Llama 3.2 3B, Phi-4, Qwen 2.5 7B) at the edge or directly on a Bun runtime. Latency drops dramatically. Privacy improves.

For genuinely small workloads, this can collapse your inference bill to near zero. Worth experimenting with if your use case is forgiving (autocomplete, classification, simple summarization). For deeper exploration, see our self-hosted LLM guide.

The Vercel question, head on

Should you actually leave Vercel?

If you ship a Next.js app with light AI features (a chatbot, occasional summarization, some embedding for search), Vercel is fine. Use the AI SDK. Pay the bill. Move on with your life.

If your AI use is intense, persistent, or pricing-sensitive, plan the migration now. The good news is that the AI SDK is portable. You can run it on Cloudflare Workers, on Hono on a VPS, on AWS Lambda. The Next.js part is the harder migration, not the AI SDK itself. Tools like Coolify or Dokploy can deploy Next.js on a netcup or Hetzner VPS with Vercel-like ergonomics. We wrote about self-hosted Vercel alternatives in detail.

The pattern we have seen most often in 2026: keep the marketing site and lightweight pages on Vercel. Move the AI backend and heavy API routes to a Hetzner or Railway-hosted service. Your bandwidth-heavy AI traffic stops counting against Vercel. Your bill drops 70-90%. The split-stack adds some complexity but pays for itself in month one.

What to actually pick

If you are a TypeScript team building an agent product: Mastra on Cloudflare Workers or a small European VPS from netcup or Hetzner. Modern, flexible, no lock-in.

If you are a Python team building agents: LangGraph if you need complex flows and tooling, PydanticAI if you want minimal and type-safe. Either runs on any cheap VPS.

If you are RAG-heavy: LlamaIndex on Python with pgvector on the same VPS. Often the entire stack runs on one VPS under 10 EUR, such as a netcup VPS 500 G12 at €5.91.

If you are OpenAI-committed and shipping fast: OpenAI Agents SDK, host anywhere.

If your needs are simple and you hate framework churn: Anthropic or OpenAI SDK directly, Hono for the HTTP layer, deploy to whatever you already pay for.

If you are starting today, on Next.js, with light AI needs: Vercel AI SDK is still the path of least resistance. Just keep an eye on the bill.

The choice of framework matters less than the discipline to actually measure what your AI features cost per active user. That measurement is what will tell you when to migrate, where to migrate to, and whether the migration is worth your team's time. Build the dashboard before you need it.

Originally published at hostingsift.com

AMD vs Intel Dedicated Servers in 2026: 109 Plans Priced per Core

HostingSift — Mon, 21 Sep 2026 07:55:26 +0000

Search for AMD vs Intel dedicated server and you get a dozen vendor blogs arguing architecture. Zen 5 against Granite Rapids, IPC deltas per watt. Almost none of them print a price, and not one prints a competitor's price. So we did the boring version: took every dedicated server in our database on 21 September 2026, looked up the actual CPU model in each one, counted the physical cores, and divided.

The result is not what the vendor essays imply. Intel cores are cheaper. Median $9.68 per physical core per month against AMD's $13.06, a 26% gap in Intel's favour across 106 plans at 12 hosts.

Then you look at what those Intel cores actually are. The median Intel chip on sale is from 2019. The median AMD chip is from 2022. Nearly two thirds of the Intel inventory runs silicon launched in 2019 or earlier, against a fifth of the AMD inventory. What reads as a vendor discount is mostly a discount on age.

What is in the sample

Snapshot taken 21 September 2026, 01:33 UTC, from our nightly scrape.

215 active dedicated plans with a price, across 21 providers
167 of them currently orderable (the rest are catalogue entries their host lists as out of stock)
109 orderable plans name a CPU we can identify and a core count, across 12 hosts
Three of those 109 carry a GPU that sets the price rather than the CPU (Hetzner GEX45 and GEX131, OVHcloud RISE-GPU-1). They are held out of every median below, which leaves 106
A further 58 orderable plans publish a core count but no CPU model, so they appear in the price-per-core ranking and nowhere in the vendor or generation cuts

Core counts are physical cores, never threads. Where the plan text gives a number we use it; where it does not (OVHcloud and InMotion publish model names only) we take the count from the part's spec sheet. Euro prices convert at a flat 1.15 and are quoted in euro as well, because that is what the invoice says.

Price per core by chip launch year

Forget the logos for a moment and sort the same 106 plans by the year their processor shipped.

CPU launch era	Plans	Median $/core/mo	Cheapest	Dearest
2011 to 2016	7	$9.99	$6.25	$30.00
2017 to 2019	33	$9.10	$2.82	$43.75
2020 to 2022	29	$12.79	$5.32	$45.31
2023 to 2025	37	$14.23	$4.85	$49.17

A core from 2023 or later costs 56% more than a core from 2017 to 2019. That single column does more work than every vendor-versus-vendor comparison on the first page of Google.

Now split each era by vendor, which is the comparison the architecture blogs claim to be making.

CPU launch era	Intel plans	Intel median	AMD plans	AMD median
2011 to 2016	7	$9.99	0	n/a
2017 to 2019	21	$9.01	12	$9.55
2020 to 2022	9	$9.56	20	$15.89
2023 to 2025	7	$16.87	30	$13.72

Two things fall out. In the 2017 to 2019 era the vendors are within 6% of each other, which is noise. And in the newest era the sign flips: Intel's seven current-generation plans are 23% dearer per core than AMD's thirty. The brand premium everyone argues about is real, it just points in different directions depending on which year you shop in, and it is smaller than the gap between any two years.

There is no AMD column before 2017 because there is no AMD silicon that old on sale. Naples shipped in 2017 and the hosts that still rack pre-2017 boxes are running Xeons.

AMD vs Intel inside a single host

Cross-provider medians are useful for shape but they mix datacentres, networks and support tiers. The cleaner test is a host that sells both vendors at the same core count.

Host	Cores / RAM	Intel plan	AMD plan	Gap
Hetzner	48c / 128 GB DDR5 ECC	DX154, Xeon 6741P (2025), €704 / $809.60	AX162, EPYC 9454P (2022), €614 / $706.10	Intel +14.7%
Namecheap	32c / 128 GB DDR4	Dual Xeon Gold 5218 (2019), $160.64	Dual EPYC 7313 (2021), $170.24	AMD +6.0%
OVHcloud	12c / 64-96 GB	SYS-5, Xeon Silver 4214R (2020), €94.99	RISE-M, Ryzen 9 9900X (2024), €94.99	0.0%
OVHcloud	8c / 64 GB	RISE-2, Xeon E-2388G (2021), €61.74	RISE-S, Ryzen 7 9700X (2024), €61.74	0.0%
Vultr	8c bare metal	E-2388G (2021), 128 GB, $350	EPYC 4345P (2025), 64 GB, $365	AMD +4.3%, half the RAM
Vultr	6c bare metal	E-2286G (2019), 32 GB, $185	EPYC 4245P (2025), 32 GB, $295	AMD +59.5%

Four of the six gaps are under 15%. Two are zero to the cent. The one big number, Vultr's 6-core pair, is a 2019 Xeon against a 2025 EPYC, so it is a generation gap wearing a vendor costume.

The Hetzner row has a third plan that makes the point better than any of this. Hetzner sells the same EPYC 9454P twice: once as AX162 in its own chassis at €614, and once as DX182 in a Dell PowerEdge at €724. Identical processor, identical 48 cores, identical 128 GB of DDR5 ECC. The Dell badge costs €110 a month, which is 17.9%. That is more than Hetzner charges to move you from AMD to Intel at the same core count. The chassis brand is a bigger line item than the CPU brand.

All three Hetzner figures were checked against hetzner.com on the day of writing, not just against our own scrape: AX162 €614.00, DX154 €704.00, DX182 €724.00, all excluding VAT, all at the German locations.

The clearest example: €59 at Hetzner

Hetzner has exactly two dedicated servers at €59.00 a month. They are also the only two of its fifteen with no setup fee.

Plan	CPU	Launched	Cores	RAM	$/core/mo
EX44	Intel Core i5-13500	2023	14	64 GB DDR4	$4.85
AX41	AMD Ryzen 5 3600	2019	6	64 GB DDR4	$11.31

Same price, same memory, 2.3x the cores. If you read only the vendor blogs you would expect the AMD box to be the core-count bargain. It is the opposite, because the i5-13500 is a 2023 hybrid part and the Ryzen 5 3600 is a six-core chip from 2019 that Hetzner has been selling for years.

One honest qualifier the marketing pages skip: those 14 cores are not 14 of the same thing. The i5-13500 is 6 performance cores plus 8 efficiency cores. For a build farm, a CI runner or anything embarrassingly parallel that is a genuine 14, and at $4.85 a core it is the best modern-silicon deal in the whole sample. For a single-threaded latency workload you have 6 fast cores and 8 helpers. Hetzner's EX63 has the same shape: Core Ultra 7 265, 20 cores, of which 8 are performance cores.

While we were verifying those two prices on hetzner.com we pulled the setup fees, which no price-per-core table anywhere seems to include:

Plan	Monthly	Setup, one off	Setup as share of one month
AX41 / EX44	€59	€0	0%
SX65	€84	€39	46%
AX42	€99	€49	49%
EX63	€149	€74	50%
AX162	€614	€304	50%
DX294	€919	€459	50%

Half a month up front on everything except the two €59 boxes. On a three-month project that quietly adds 17% to the bill.

What a newer generation costs at the same host

The strongest evidence for the generation thesis is inside a single provider, same vendor, same core count, different silicon year. Only like-for-like billing terms are compared here, because a monthly list price against a two-year committed rate will produce any multiple you want.

Host	Older	Newer	Multiple
InterServer, 24c EPYC, monthly	7402P (2019), $399	9254 (2022), $720	1.80x
Liquid Web, 16c Xeon, monthly list	6226R (2020), $335	6526Y (2023), $564	1.68x
Ultahost, 24c EPYC, 3-year term	7401P (2017), $239.74	9224 (2022), $341.88	1.43x
PebbleHost, 12c Ryzen 9, monthly	7900 (2023), $99.99	9900X (2024), $139.99	1.40x
OVHcloud, 24c EPYC, 2-year term	7451 (2017), €58.89	7413 (2021), €170.99	2.90x

InterServer's ladder is the cleanest because all three rungs are plain monthly prices at one provider: EPYC 7402P from 2019 at $399, 7443P from 2021 at $450, 9254 from 2022 at $720. Twenty-four cores each time. The bill goes up 80% while the core count stays put.

Liquid Web deserves a footnote, and it is the kind of footnote that should make you distrust round numbers in other people's tables. Our database records $167.50 a month for the 16-core Xeon 6226R, which would make the jump to the 6526Y look like a 2.9x increase. It is not. The $167.50 is Liquid Web's "50% off first 2 months" intro rate and it renews at $335, while the 6526Y figure we store is a two-year committed rate whose monthly equivalent is $564. Matched term against matched term, both the monthly pair and the two-year pair give the same answer: 1.68x.

Two counter-examples keep this honest. Vultr sells the Xeon E-2288G (2019) and E-2388G (2021) as 8-core, 128 GB bare metal boxes at exactly $350 each. Two years of silicon, zero price difference. And OVHcloud's €85.49 price point buys either a 16-core EPYC 7371 from 2019, an 8-core Ryzen 7 5800X from 2020, or a 6-core EPYC 4244P from 2024. Same money, $6.14 versus $12.29 versus $16.39 per core, a 2.67x spread inside one price point at one provider.

Cheapest dedicated server per core, and the other end

Across the 106 orderable, vendor-identified plans the spread is 17.4x, from $2.82 to $49.17 per core per month. Drop Vultr's bare metal line, which is its own pricing universe, and it is still 11.2x.

Plan	Host	CPU	Cores	Price/mo	$/core
KS-7	OVHcloud	EPYC 7451 (2017)	24	€58.89 / $67.72	$2.82
KS-4	OVHcloud	Xeon E3-1230 v6 (2017)	4	€16.14 / $18.56	$4.64
EX44	Hetzner	Core i5-13500 (2023)	14	€59.00 / $67.85	$4.85
2 x Xeon Platinum 8173M	InterServer	Platinum 8173M (2017)	56	$279.00	$4.98
Dual Xeon Gold 5218	Namecheap	Gold 5218 (2019)	32	$160.64	$5.02
Dual EPYC 7313	Namecheap	EPYC 7313 (2021)	32	$170.24	$5.32
RISE-XL	OVHcloud	EPYC Turin 9455 (2024)	48	€284.99 / $327.74	$6.83

That last row is the one worth staring at. RISE-XL is a 48-core Turin part, current generation, at $6.83 per core. Hetzner's AX162, a 48-core Genoa from 2022, is $14.71 per core. Both are single-socket European boxes with DDR5 ECC. The 2.2x between them comes from two companies picking different margins, one on a two-year signature and one on a month-to-month box.

At the expensive end the story is entirely about who is selling, not what:

Plan	Host	CPU	Cores	Price/mo	$/core
Bare Metal EPYC 4245P	Vultr	EPYC 4245P (2025)	6	$295.00	$49.17
Bare Metal EPYC 4345P	Vultr	EPYC 4345P (2025)	8	$365.00	$45.63
Bare Metal Intel E-2288G	Vultr	Xeon E-2288G (2019)	8	$350.00	$43.75
SX295	Hetzner	EPYC 7502P (2019)	32	€879 / $1010.85	$31.59
Essential / Advanced / Elite	InMotion	Xeon E-2134 / E-2176G / E-2388G	4 / 6 / 8	$119.99 / $179.99 / $239.99	$30.00

InMotion's three managed tiers land on exactly $30.00 per core, which is not a coincidence, it is a price list built on a per-core rate card. Hetzner's SX295 is a storage server: 256 GB of RAM, two NVMe drives and fourteen 22 TB hard disks, so its CPU-normalised number badly overstates what you are paying for compute. Vultr's bare metal sits three to ten times above the same chip elsewhere because you are renting hourly billing and an API, not a server.

Price per core by host

Median across every orderable, vendor-identified plan each host sells.

Host	Plans	Median $/core/mo	Billing basis in our data
Servarica	1	$5.60	monthly
OVHcloud	30	$9.10	24-month term
Namecheap	12	$9.21	monthly
PebbleHost	8	$9.37	monthly
Contabo	4	$10.91	12-month term
Liquid Web	4	$14.35	mixed, see note
Hetzner	13	$14.71	monthly
InterServer	9	$15.81	monthly
Ultahost	7	$17.07	36-month term
ExtraVM	3	$24.92	monthly
InMotion	5	$30.00	12-month term, managed
Vultr	10	$42.61	monthly, hourly available

The billing column is not decoration. OVHcloud's $9.10 assumes you sign for 24 months; Ultahost's $17.07 assumes 36. Servarica's single row is a plan advertised as “20 to 24 cores” and we counted 20, the conservative end, which is why one plan gets to sit at the top. Contabo's figure is its 12-month rate, and at the plain monthly price its median moves from $10.91 to roughly $12.46. Compare hosts across this table and you are comparing commitments as much as hardware. Our dedicated hosting category page has the full plan-level detail for each of these.

Management is priced separately and, at least at HostPapa, it is a flat fee rather than a percentage. Unmanaged Spark $59.95 becomes Managed Spark $109.95. Pulse $99.95 becomes $149.95. Drive, Ignite and Surge all do the same thing: exactly $50.00 a month, from the smallest box to the $524.95 one. HostPapa does not publish CPU models, so those plans sit outside the vendor index, but the pattern is worth knowing before you assume managed hosting scales with server size.

On the cloud side the brand is nearly free

Bare metal is where vendor choice costs money. On virtual machines it mostly does not.

DigitalOcean sells its Basic Premium droplets in an Intel version and an AMD version at nine matched shapes. Intel costs exactly 8/7 of AMD on every single one, a 14.29% premium that never varies:

Shape	Premium AMD	Premium Intel	AMD NVMe	Intel NVMe
1 vCPU / 1 GiB	$7	$8	25 GiB	35 GiB
2 vCPU / 4 GiB	$28	$32	80 GiB	120 GiB
4 vCPU / 16 GiB	$84	$96	200 GiB	320 GiB
8 vCPU / 32 GiB	$168	$192	400 GiB	640 GiB

The Intel droplet ships 1.4x to 1.6x the NVMe at every size. The surcharge buys disk, and the CPU brand comes along for the ride.

Vultr goes further. Its High Performance line is sold in both flavours, and the vendor is exposed in the public plans API as a cpu_vendor field, so this is checkable in one curl. All eight shapes, from 1 vCPU / 1 GiB at $6 up to 12 vCPU / 24 GiB at $144, are identical in price, RAM, NVMe and bandwidth between the AMD and Intel versions. Not close. The same number. Vultr's High Frequency line, also Intel, matches those prices at the four overlapping shapes and adds 25% to 33% more NVMe, while halving the transfer allowance from 2 TB to 1 TB.

If you have been choosing cloud instances by CPU vendor and expecting a discount, there is no discount to find at Vultr and a 14.29% disk-shaped one at DigitalOcean. We went through the related question of dedicated versus shared vCPU pricing in a separate piece, and the per-gigabyte-of-RAM view in this one.

Dedicated prices barely move

We snapshot every plan nightly, which means we can say how long these numbers have actually held rather than just quoting today's page.

Of the 167 orderable dedicated plans, 123 (73.7%) have shown exactly one price across our entire series. Not one change. Some specifics:

OVHcloud: 31 of 31 plans unchanged across 148 days of readings, from 1 April 2026 to today. The entire Eco, Rise and Advance catalogue, frozen.
PebbleHost: 8 of 8 unchanged across 159 days of readings, since 17 March 2026.
Vultr bare metal: 10 of 10 unchanged, eight of them from 22 February 2026, where our series begins.
Namecheap is the exception. Only 5 of its 12 plans have held one price, and the Dual Xeon Gold 5218 has carried five different prices over 179 days of readings. If you are quoting Namecheap dedicated pricing, date your quote.
IONOS changed all 10 of its dedicated plans at least once, Contabo all 4, InMotion all 5.

So the per-core table above is not a one-day photograph for most of this market. For three quarters of it, the plan has never once shown us a different number since we started reading it. You can watch the ones that do move on our price trends page.

Where this table could mislead you

Corrections we would want applied to somebody else's price-per-core article, applied to ours.

The price basis is not uniform. We use the lowest advertised monthly-equivalent each host shows, and hosts advertise on different commitments: OVHcloud on 24 months, Contabo on 12, Ultahost and Bluehost on 36, Hetzner and Namecheap and InterServer and Vultr and PebbleHost on plain monthly. Comparing OVHcloud's $9.10 to Hetzner's $14.71 compares a two-year signature to a month-to-month one.

Intro rates hide inside monthly prices. Liquid Web's $167.50 is half price for two months. We caught it because the same record carries a $335 renewal figure. Where a host does not publish a renewal price, we cannot catch it at all, which is a problem we wrote about in our study of which hosts publish renewal pricing.

A core is not a core. Hybrid Intel desktop parts inflate the count against server Xeons and EPYCs. Dual-socket 2017 Xeons give you 56 cheap cores with 2017 per-core performance and 2017 memory bandwidth. An EPYC Turin core and a Xeon E5 core from 2013 are the same row in this table and nothing alike in a benchmark. Price per core is a purchasing metric, not a performance one.

Out-of-stock plans are excluded, and some of them are the cheap ones. OVHcloud's KS-B at €9.49 would be $2.73 per core and would top the cheapest list, but you cannot order it, so it is not in the ranking. Seventeen OVHcloud plans are in that state right now, along with all seven of Private Hosting's and fourteen of Servarica's fifteen.

Two data points we are deliberately not making claims about. Hetzner's dedicated price history before 11 September 2026 is unusable in our series: our scraper alternated between the price of the currently available configuration and the base catalogue price on the same plan on the same night, so AX162 shows both €319 and €614 in overlapping runs. The current values are catalogue prices and we verified all thirteen of them against hetzner.com rather than trusting the series. And Ultahost's ULTA-X11 is advertised as "64-Core AMD EPYC 9454" although that part has 48 cores; we used their number and flag it here.

What I would actually buy

Four workloads, four picks, with the number that decides each one.

Cheapest usable cores, throughput work, you do not care about per-core speed. OVHcloud KS-7: EPYC 7451, 24 cores, €58.89 on a two-year term, $2.82 per core. Nothing else in the sample is within 60% of it. Naples cores from 2017 are slow and the memory subsystem shows its age, so this is a build farm or a batch queue, not a database.

Cheap cores that are actually fast. Hetzner EX44 at €59, no setup fee, $4.85 per core. Six Raptor Lake performance cores clock higher than anything on the budget lists and the eight efficiency cores are free parallelism. Verified live on hetzner.com on 21 September 2026.

Many cores for a database. Namecheap's Dual Xeon Gold 5218 at $160.64 gives 32 cores and 128 GB for $5.02 a core. If you want newer silicon for the same job, the Dual EPYC 7313 at $170.24 is $9.60 more per month. That $9.60 is the entire "AMD premium" at this size, and it buys you Milan instead of Cascade Lake. Take it. Then date your quote, because Namecheap is the one host here that moves its dedicated prices.

Current generation, single socket, production. OVHcloud RISE-XL: 48 Turin cores at $6.83 each. Hetzner's AX162 is 2.2x the per-core price for 2022 Genoa, and the reasons to pay it are the monthly term and the network, not the chip.

The pattern under all four: in September 2026, on 106 servers we can price by the core, the launch year of the processor moves the number far more than the logo printed on it. Anyone selling you an AMD-versus-Intel decision without telling you the model year is selling you the wrong variable.

Originally published at hostingsift.com.

Dedicated vs Shared vCPU: What the Premium Actually Costs in 2026

HostingSift — Sun, 13 Sep 2026 08:10:48 +0000

On Vultr, a dedicated vCPU costs 2.8 times as much as a shared one. Also on Vultr, it costs 12.5% more. Both figures come off the same price list on 13 September 2026: $10 against $28 for a server with 1 vCPU and 2 GB of RAM, and $640 against $720 for one with 24 vCPUs and 96 GB.

Providers sell "dedicated CPU" as one upgrade with one meaning. The price attached to it swings by a factor of 2.5 depending on who you buy from and how big you go. We took every shared and dedicated plan that has the exact same vCPU count and RAM at the same provider and found 18 matching pairs across four hosts. The premium ranged from 1.13x to 2.80x. At Vultr it shrinks as the server grows, while DigitalOcean and Linode lock it to a fixed multiple. And at Linode, once you need eight cores or more, the dedicated line is the cheaper way to buy them.

What a shared vCPU actually gives you

A shared vCPU is a slice of a hardware thread that other customers can be scheduled on too. DigitalOcean's documentation says so plainly: on a Basic Droplet, "the hyper-thread allocated to the Droplet may be shared between multiple other Droplets," and when those neighbours are busy, "a Droplet could receive fractions of hyper-threads instead of dedicated access to the underlying physical processors." Dedicated CPU Droplets "have guaranteed access to the full hyper-thread at all times" (DigitalOcean docs).

Akamai, which runs Linode, puts a number on it. Shared CPU cores "can be used at 100% for short bursts, but should remain below 80% sustained usage on average" (Akamai shared CPU docs). Dedicated instances are pitched for "sustained full-duty workloads (100% CPU all day, every day)" (Akamai dedicated CPU docs).

That 80% line is the most useful sentence any host has published on the subject. A shared vCPU is a core you may spike but should not pin.

How to see contention from inside the server

Time the hypervisor hands to someone else shows up as steal. In top it is the st field, which the man page defines as "time stolen from this vm by the hypervisor" (top(1)). vmstat reports the same figure in its own st column.

vmstat 1 30
# read the "st" column while your app is under load

A value that stays near zero while your service is busy means the neighbours are quiet. A value that climbs at the same moment your response times do means you are paying for their workloads in latency, and that is the evidence worth acting on.

Burst credits are shared CPU with a written limit

Some providers replace the vague fair-share arrangement with a meter. AWS burstable instances earn CPU credits below a baseline and spend them above it. A t3.micro's baseline is 10% per vCPU, and in Standard mode an instance that runs out of credits "gradually comes down to baseline CPU utilization and cannot burst above baseline until it accrues more credits." In Unlimited mode it keeps going and bills the surplus (AWS docs). Kamatera's Type T uses the same idea in plain dollars: "Exceeding an average CPU usage of 10% will be extra charged" (Kamatera FAQ).

The advantage of a meter is that you can read the ceiling before you hit it. With an ordinary shared vCPU you find the ceiling by hitting it.

How we matched the plans

Prices are from our nightly catalog read of 13 September 2026. The same day we checked Linode against Akamai's pricing page and public API, Vultr against its public plans API, DigitalOcean against its Droplet pricing page, and Hetzner, Contabo and Kamatera against their own pages.
The class comes from the product line, because a plan's CPU label almost never says "shared". DigitalOcean Basic Droplets count as shared; General Purpose and CPU-Optimized as dedicated. Linode Shared CPU against Dedicated CPU. Vultr Cloud Compute against Optimized Cloud Compute, which Vultr's docs call "dedicated virtual machines" (Vultr docs). Contabo Cloud VPS against Cloud VDS.
A pair means the same provider, the same number of vCPUs and the same RAM. Where several plans in one class fit a shape, the cheapest counts.
Monthly list prices in the currency the host bills. Contabo's figures are its 24-month-term rates. Both Contabo lines use the same term discounts, so the ratio is identical on a monthly contract (€25.00 against €69.00 for the 12-core pair).
Not in the pair table: Hetzner and Kamatera, which have no matching shapes and get their own section below. Fly.io is out too, because its shared machines start at 256 MB per vCPU and its performance machines at 2 GB, so nothing lines up. So is DigitalOcean App Platform, a PaaS rather than a server.

The premium, pair by pair

Provider	vCPU / RAM	Shared plan	Dedicated plan	Premium	Disk (shared / dedicated)
DigitalOcean	2 / 4 GB	Basic Regular, $24	CPU-Optimized, $42	1.75x	80 / 25 GiB
DigitalOcean	2 / 8 GB	Basic Premium AMD, $42	General Purpose, $63	1.50x	100 / 25 GiB
DigitalOcean	4 / 8 GB	Basic Regular, $48	CPU-Optimized, $84	1.75x	160 / 50 GiB
DigitalOcean	4 / 16 GB	Basic Premium AMD, $84	General Purpose, $126	1.50x	200 / 50 GiB
DigitalOcean	8 / 16 GB	Basic Regular, $96	CPU-Optimized, $168	1.75x	320 / 100 GiB
DigitalOcean	8 / 32 GB	Basic Premium AMD, $168	General Purpose, $252	1.50x	400 / 100 GiB
Linode	2 / 4 GB	Linode 4GB, $24	Dedicated 4GB, $36	1.50x	80 / 80 GB
Linode	4 / 8 GB	Linode 8GB, $48	Dedicated 8GB, $72	1.50x	160 / 160 GB
Vultr	1 / 2 GB	CC Regular, $10	Optimized CPU, $28	2.80x	55 / 25 GB
Vultr	2 / 4 GB	CC Regular, $20	Optimized CPU, $40	2.00x	80 / 50 GB
Vultr	4 / 8 GB	CC Regular, $40	Optimized CPU, $80	2.00x	160 / 75 GB
Vultr	4 / 16 GB	CC High Frequency, $96	Optimized General Purpose, $120	1.25x	384 / 80 GB
Vultr	8 / 16 GB	CC High Performance, $96	Optimized CPU, $160	1.67x	350 / 150 GB
Vultr	8 / 32 GB	CC Regular, $160	Optimized General Purpose, $240	1.50x	640 / 160 GB
Vultr	16 / 64 GB	CC Regular, $320	Optimized General Purpose, $480	1.50x	1,280 / 320 GB
Vultr	24 / 96 GB	CC Regular, $640	Optimized General Purpose, $720	1.13x	1,600 / 480 GB
Contabo	12 / 48 GB	Cloud VPS 12, €20.00	Cloud VDS L, €55.20	2.76x	400 / 360 GB
Contabo	16 / 64 GB	Cloud VPS 16, €29.60	Cloud VDS XL, €75.20	2.54x	500 / 480 GB

Seven of the 18 pairs land on exactly 1.50x. The outliers sit at the two ends of Vultr's range and at Contabo.

Contabo's ratio is high because its shared side is so cheap. Its basic Cloud VPS plans cost €1.00 to €2.18 per vCPU per month on a 24-month term, far below anything else in this set (see its price history). The Cloud VDS line, according to Contabo, gives you "dedicated CPU and RAM inside a virtualized environment" with resources "committed to your instance alone, not pooled across tenants like a shared VPS." The same page concedes that a VDS "is also hosted on a shared physical server" (Contabo VDS).

Small servers pay the steepest markup

Vultr shows the size effect most clearly. Its smallest dedicated plan, Optimized CPU with 1 vCPU and 2 GB, costs $28. The shared plan of the same shape costs $10. For $20 you could have the shared 2 vCPU, 4 GB plan instead, which is twice the cores and twice the memory for $8 a month less than the single dedicated core.

Further up, the markup falls away. Against the Regular plans it goes from 2.80x at 1 vCPU to 2.00x at 2 and 4, then 1.50x at 8 and 16, and finally 1.13x at 24 vCPUs, where dedicated adds $80 to a $640 bill. Dedicated has a price floor at the bottom, and Vultr's shared line gets more expensive per core as it grows: $10 per vCPU on the Regular plans in the table up to 4 cores, $20 at 8 and 16, $26.67 at 24. Optimized General Purpose holds at a flat $30 per vCPU from 1 core to 64.

DigitalOcean and Linode do something different and keep the ratio fixed. DigitalOcean's CPU-Optimized Droplets cost exactly 1.75x the Basic Regular Droplet of the same shape at every size we could match. General Purpose costs exactly 1.50x Basic Premium AMD. Linode lands on 1.50x because it prices both lines by memory: $6 per GB of RAM on shared plans (the $5 Nanode aside) and $9 per GB on dedicated plans, without a single exception on either list. If you want the per-GB view across the whole market, we ran it in our VPS price per GB of RAM index.

Where dedicated is the cheaper way to buy cores

Linode's per-GB pricing has a side effect worth knowing about. As shared plans grow, they add memory faster than cores: 2 GB per vCPU at the bottom, 4 GB per vCPU at 8 and 16 cores, 6 GB per vCPU at 32. The dedicated line stays at 2 GB per vCPU all the way to 48 cores. Priced per core, the two lines cross between 6 and 8 vCPUs.

vCPUs	Cheapest shared plan	Shared $/vCPU	Cheapest dedicated plan	Dedicated $/vCPU
2	Linode 4GB (4 GB), $24	$12.00	Dedicated 4GB (4 GB), $36	$18.00
4	Linode 8GB (8 GB), $48	$12.00	Dedicated 8GB (8 GB), $72	$18.00
6	Linode 16GB (16 GB), $96	$16.00	No 6-core plan	n/a
8	Linode 32GB (32 GB), $192	$24.00	Dedicated 16GB (16 GB), $144	$18.00
16	Linode 64GB (64 GB), $384	$24.00	Dedicated 32GB (32 GB), $288	$18.00
32	Linode 192GB (192 GB), $1,152	$36.00	Dedicated 64GB (64 GB), $576	$18.00

At 32 vCPUs the dedicated plan costs half as much. You give up 128 GB of RAM to get there, and that is the whole point. If your build farm or encoder is CPU-bound and fits in 64 GB, the shared plan charges you $576 a month for memory you will never touch.

One caveat from outside our tracked catalog. Akamai's North America pricing page, checked on 13 September 2026, describes both the shared plans and the G6 dedicated plans above as running on legacy hardware, and lists a newer G8 Dedicated line at higher prices: $50.40 for 2 vCPUs and 4 GB, $194.40 for 8 vCPUs and 16 GB (Akamai pricing). On G8, 8 and 16 cores cost about the same as the shared plans with the same core count. The dedicated line only pulls clearly ahead at 32 vCPUs, $777.60 against $1,152.

Dedicated plans usually ship with less disk

The premium column hides a second cost. In 16 of the 18 pairs, the dedicated plan comes with less storage than the shared plan it replaces. Linode is the only one of the four that keeps disk identical across both lines.

DigitalOcean at 2 vCPUs and 4 GB: 80 GiB on Basic, 25 GiB on CPU-Optimized, for $18 more per month.
Vultr at 4 vCPUs and 16 GB: 384 GB on High Frequency, 80 GB on Optimized General Purpose.
Vultr at 24 vCPUs and 96 GB: 1,600 GB on Cloud Compute Regular, 480 GB on Optimized.

Some of that gap is a change of drive type. Vultr's Regular plans and Contabo's Cloud VPS list plain SSD, while their dedicated lines list NVMe. But if you are sizing a database, read the disk column before the CPU label, because extra block storage is a separate monthly charge that no premium ratio includes.

Hetzner and Kamatera don't fit the grid

Hetzner makes more sense matched by memory

Hetzner has no shared and dedicated cloud server with the same cores and memory. Its dedicated CCX line gives 4 GB of RAM per vCPU; the shared CPX line gives 2 GB. The cheapest shared lines, CX and the Arm-based CAX, were also not orderable when we read the catalog on 13 September 2026: 8 of Hetzner's 14 shared cloud plans were marked unavailable. (Our ARM VPS guide covers what CAX-style Arm servers are good for.) That leaves CPX as the shared line you can actually buy.

Per vCPU, CPX costs €8.12 to €11.49 a month and CCX costs €16.67 to €21.50, before VAT and the IPv4 address. That reads like a 2x premium. Match the plans by RAM instead and most of it disappears.

RAM	Shared (CPX)	Dedicated (CCX)	Premium
8 GB	CPX32, 4 vCPU, €35.49	CCX13, 2 vCPU, €42.99	1.21x
16 GB	CPX42, 8 vCPU, €69.49	CCX23, 4 vCPU, €85.99	1.24x
32 GB	CPX62, 16 vCPU, €129.99	CCX33, 8 vCPU, €138.49	1.07x

So the real Hetzner question is whether half as many dedicated cores beat twice as many shared ones with the same memory. For a Postgres server with 32 GB, eight dedicated cores for €8.50 more than sixteen shared ones is an easy call.

The gap also moved this year. Hetzner's repricing of 15 June 2026 took CCX13 from €15.99 to €42.99 and CPX22 from €7.99 to €19.49, for new orders and rescales (Northflank's breakdown). Before it, a dedicated vCPU on those two plans cost exactly twice a shared one, €8.00 against €4.00. Afterwards it is 2.21x. Nothing about the hardware changed that morning, which tells you the premium is a pricing decision, and pricing decisions move. Hetzner's price trend page tracks where it goes next.

Kamatera sells four steps, and they are different units

Kamatera's headline gap is the widest we found. A server with 1 vCPU, 1 GB of RAM and 20 GB of NVMe costs $4 a month as Type A and $19 as Type D, which reads as 4.75x. The two types don't sell the same thing, though. From Kamatera's own definitions (Kamatera FAQ):

Type A (Availability), from $4 a month: "a non-dedicated physical CPU thread with no resources guaranteed."
Type B (General Purpose), from $9: "a dedicated physical CPU Thread with reserved resources guaranteed."
Type T (Burstable): a dedicated thread, with usage above a 10% average billed on top.
Type D (Dedicated), from $19: "a dedicated physical CPU Core (2 threads)."

Type D gives you two threads, which makes it $9.50 per thread, within 50 cents of Type B's $9 starting price. The step that buys a guarantee at Kamatera is A to B, about 2.25x on starting prices. Type D is for workloads that want both threads of a physical core to themselves. Kamatera's price history shows the current list.

These prices sit still

Nothing above comes from a flash sale. All 90 active DigitalOcean plans have shown one price each on every one of the 179 nightly readings we have taken since 12 February 2026. Linode's 39 plans have not moved across 169 readings since 24 February. Vultr's Cloud Compute and Optimized lines have held one price per plan since late February. The flat lines are visible on the DigitalOcean, Linode and Vultr trend pages. Hetzner, as covered above, is the exception.

That stability matters for the decision. On these three clouds the ratio has not budged in more than six months, so the premium is something you can plan a budget around.

When dedicated vCPU earns its price

Pay for dedicated when your CPU stays busy for hours at a time. CI runners, video transcoding, game servers and data analysis all appear on Akamai's list of dedicated workloads, and if your average sits above Linode's 80% sustained line, a shared plan is the wrong product at any price.

Latency-sensitive services are the second case. A database behind a checkout, or an API with a p99 target, suffers from a noisy neighbour long before the monthly CPU graph looks alarming. Watch st during your busiest hour. If it rises with your response times, the premium is buying you something.

Skip dedicated for blogs, low-traffic web servers and development environments, which is where DigitalOcean's own guidance places Basic Droplets. Staging boxes and internal tools belong in the same bucket. On small plans with a 2x or larger markup, my advice is to buy the next shared size up. Extra cores give a busy app headroom for less money, and if steal still shows up at that size, you will have the vmstat numbers to justify the upgrade.

What I would buy at each size

WordPress site, staging box or side project: Vultr's shared 2 vCPU, 4 GB plan at $20. Hetzner CPX22 at €19.49 if you would rather be billed in euros.
CI runner or encoder that needs 8 cores all day: Linode Dedicated 16GB at $144. It undercuts Linode's own shared 8-core plan by $48, and beats the nearest dedicated rivals, Vultr Optimized CPU at $160 and DigitalOcean CPU-Optimized at $168. If you are weighing the two US clouds head to head, the Linode vs Vultr page has the full catalogs.
Database with 32 GB of RAM: Hetzner CCX33 at €138.49, €8.50 more than the shared CPX62.
A 24 vCPU, 96 GB production box: pay Vultr the extra $80 for Optimized General Purpose ($720). At 1.13x it is the smallest markup among the 18 matched pairs.

And the one purchase I would avoid: a single dedicated core under $30, like Vultr's $28 Optimized CPU plan. Put $20 into two shared vCPUs and 4 GB, run vmstat under real traffic, and move to dedicated when steal shows up and not before. More plans sit in our VPS hosting and cloud hosting listings.

Originally published at hostingsift.com.

Hosting Renewal Prices: Which of 50 Hosts Actually Publish One

HostingSift — Mon, 07 Sep 2026 19:02:25 +0000

Every hosting price page shows you a number. Some of them show you two.

We scrape 50 providers every night. As of 7 September 2026 our database holds 1,441 active plans that carry both a signup price and a renewal price. Half the providers publish a renewal figure that differs from the signup figure somewhere in their catalog. The other half publish one rate and stop there.

That split is 25 against 25, and it is a far better predictor of your second-year bill than anything else we can measure.

Group	Providers	Active plans	Plans that renew higher
Publish a renewal price	25	645	418 (64.8%)
Publish a single price	25	796	not published, not measurable

Why every percentage here divides by 645

This matters enough to spell out before any other number. A plan that never advertises a renewal rate is not evidence of a plan that holds its price. It is an absence of evidence, and the two are easy to confuse.

Divide 418 markups by all 1,441 plans and you get 29%, which sounds like good news about the industry. That figure would be meaningless. It counts DigitalOcean's 90 metered plans and Hetzner's 40 flat-rate plans as if we had checked their renewal invoices and found no increase. We have not checked anybody's invoices. We read pricing pages.

So the denominator throughout is 645: the plans where a second published number exists to compare against. A plan counts as a markup when its published renewal rate sits more than 5% above its signup rate, which keeps rounding and currency conversion out of the count. On that basis, 64.8% of plans renew above their signup rate, and the average increase among those is 2.37x.

The 25 hosts that publish a renewal price

Provider	Plans	Renew higher	Share	Average markup
Hostinger	25	25	100%	2.75x
GoDaddy	22	22	100%	1.80x
HostArmada	21	21	100%	2.78x
Bluehost	19	19	100%	1.65x
ChemiCloud	18	18	100%	3.21x
NameHero	16	16	100%	2.75x
Scala Hosting	16	16	100%	2.18x
IONOS	15	15	100%	7.15x
HostGator	10	10	100%	2.83x
Time4VPS	36	35	97.2%	1.97x
UltaHost	51	47	92.2%	1.58x
A2 Hosting	26	23	88.5%	2.69x
GreenGeeks	15	12	80.0%	3.48x
Name.com	4	3	75.0%	1.31x
InMotion Hosting	12	8	66.7%	2.41x
HostPapa	34	22	64.7%	2.12x
Liquid Web	18	11	61.1%	1.85x
Hostwinds	49	29	59.2%	1.54x
FastComet	19	11	57.9%	2.58x
DreamHost	23	11	47.8%	1.63x
Devrims	46	21	45.7%	1.43x
SiteGround	7	3	42.9%	5.89x
Namecheap	29	11	37.9%	1.84x
OVHcloud	97	8	8.2%	2.83x
InterServer	17	1	5.9%	2.80x

The bottom two rows deserve a second look, because a low share here does not mean a gentle host. OVHcloud shows 8 markups out of 97 plans, which reads as tame until you notice all 8 are its shared hosting plans and that is all of its shared hosting plans. Its 41 cloud instances and 48 dedicated servers carry one number each. InterServer runs the same trick in reverse: its one exception is the Standard shared plan, \$2.50 at signup against a \$7.00 standard rate, sitting in a catalog otherwise built on the price lock it markets.

Nine hosts raise the price on every plan they sell

Hostinger, GoDaddy, HostArmada, Bluehost, ChemiCloud, NameHero, Scala Hosting, IONOS and HostGator have no exceptions. Across 162 plans between them, in shared hosting, WordPress, VPS, reseller, dedicated and website builders, every single one renews above its signup rate.

IONOS is the extreme. Its average markup of 7.15x is not a rounding artifact of one weird plan; it has four plans priced at \$1.00 for the first year. The eCommerce Plus builder renews at \$32.00, which is 32x. The Plus website builder goes \$1.00 to \$20.00. The Plus shared plan goes \$1.00 to \$14.00. The Grow WordPress plan goes \$1.00 to \$12.00.

Nothing here is hidden. IONOS prints both numbers on the page. Whether anyone reads the second one is a different question.

Why the renewal multiple is a bad way to shop

Here is the finding I did not expect. The size of the markup barely predicts what you pay, because the length of the introductory term varies from 12 months to 48 and swamps it.

Take entry shared plans and run them out to four years, paying the published signup rate for the length of the intro term and the published renewal rate afterwards.

Plan	Signup	Intro term	Renewal	Markup	Four-year total
A2 Hosting Starter	\$1.99/mo	48 months	\$9.99/mo	5.02x	\$95.52
Hostinger Premium	\$2.99/mo	48 months	\$10.99/mo	3.68x	\$143.52
HostArmada Start Dock	\$1.99/mo	36 months	\$9.95/mo	5.00x	\$191.04
ChemiCloud Starter	\$1.95/mo	36 months	\$11.95/mo	6.13x	\$213.60
Bluehost Starter	\$3.99/mo	36 months	\$9.99/mo	2.50x	\$263.52
FastComet Starter	\$1.99/mo	12 months	\$9.95/mo	5.00x	\$382.08
IONOS Plus	\$1.00/mo	12 months	\$14.00/mo	14.00x	\$516.00
GreenGeeks Lite	\$2.95/mo	12 months	\$13.95/mo	4.73x	\$537.60
SiteGround StartUp	\$2.99/mo	12 months	\$17.99/mo	6.02x	\$683.52

A2 Hosting's Starter plan carries one of the steeper markups in the whole dataset, 5.02x, and produces the cheapest four-year bill of any renewal-publishing shared plan we track. SiteGround's StartUp carries a similar 6.02x and costs seven times more over the same four years. The difference is entirely the term: A2 sells you 48 months up front at \$1.99, SiteGround sells you 12 at \$2.99 and then wants \$17.99.

Hostinger's own price data makes the mechanism obvious. Its Premium plan lists a 48-month total of \$143.52 against an undiscounted total of \$575.52 for the same four years. You are buying four years of discount at once. Sign the same plan for 12 months instead and the rate is \$3.99, not \$2.99.

If you want to run this for plans not in the table, our true cost calculator does the arithmetic, and the A2 Hosting vs SiteGround comparison puts those two side by side with specs attached.

What renews, by product type

Within those 645 plans, the pattern sorts cleanly by what you are buying.

Plan type	Plans	Renew higher	Share	Average markup
Shared	89	86	96.6%	3.11x
Reseller	37	34	91.9%	1.93x
WordPress	55	48	87.3%	3.00x
VPS	208	172	82.7%	1.89x
WooCommerce	10	7	70.0%	3.20x
Cloud	98	28	28.6%	1.62x
Dedicated	131	26	19.8%	1.38x
Website builder	10	10	100%	7.43x

Shared hosting at 96.6% is the number most people already suspect. VPS at 82.7% is the one that surprises, because VPS shoppers tend to assume they have escaped the promo game by moving up a tier. Among hosts that publish renewal rates, they have not. The average VPS markup is gentler, 1.89x rather than 3.11x, but four out of five plans still rise.

Dedicated servers are the safest ground at 19.8%, which makes commercial sense. Nobody signs a \$300 per month server on a teaser rate and then quietly absorbs a doubling.

The website builder line is small enough to be noise, ten plans, but the 7.43x average is real and it is mostly IONOS.

The 796 plans with one number, and what we cannot tell you

Twenty-five providers record a single rate on every plan: Vultr with 93 plans, DigitalOcean with 90, ServaRica 80, Evolution Host 71, Cloudways 63, PebbleHost 57, ExtraVM 45, Hetzner 40, Linode 39, Private Hosting 37, Kinsta 32, Contabo 26, Netcup 25, Amazon Lightsail 25, Rocket.net 18, Fly.io 14, Kamatera 10, then Shopify, Diploi, Tiiny Host, Squarespace, Wix, Railway, WP Engine and Dynadot with single digits each.

Our record for those 796 plans holds one price. That is a fact about their pricing pages, not a promise about their invoices. A host that has never printed a renewal rate has also never committed to one.

There is a structural reason to expect stability from most of this group, and it is worth understanding rather than trusting. Metered infrastructure has no anniversary date. DigitalOcean, Vultr, Linode and Amazon Lightsail bill by the hour for what is running, so there is no contract to renew and no second number to print. Cloudways, Fly.io, Kamatera and Railway work the same way. Kinsta, Rocket.net and WP Engine sell flat subscriptions and market the absence of promo pricing as a feature.

Hetzner, Contabo, Netcup and Evolution Host are the interesting middle. They sell fixed-term commitments in the way a shared host does, they just publish one rate for the term and for the renewal. That is a stronger signal than metered billing gives you, but it is still a pricing page, and pricing pages get edited. Hetzner repriced parts of its cloud range in June 2026, which tells you a flat-rate host can still move a price. It just moves it for everybody at once instead of moving it for you on your anniversary.

What we can say honestly: for the plans in this group with history going back before June, the advertised price has been stable. What we cannot say is what any of them bills you in month 25, because they never told us.

The euro pattern is a product mix pattern

Nine of the 50 providers bill in euros, covering 342 active plans, and only 43 of those renew higher. At 12.6% that looks like a continental discipline about pricing, and it is tempting to write it up that way.

It falls apart on inspection. Seven of the nine euro hosts publish a single price, so their 209 plans contribute nothing but a zero to that percentage. All 43 markups sit in exactly two catalogs. Time4VPS accounts for 35 of them and OVHcloud for the other 8. Judged on the same 645-plan basis as everyone else, euro billing carries no advantage worth naming. The euro catalog is simply full of VPS and dedicated shops, and those are the categories with the lowest markup rates in any currency.

Time4VPS is also the cleanest renewal structure in the dataset, and a useful worked example. Thirty-two of its 35 markups land on exactly 2.00x, on a 24-month term, with no variation. Compare its Container C8 against a similar Contabo box.

Plan	Specs	First 24 months	Months 25 to 48	Four-year total
Time4VPS Container C8	3 vCPU, 8 GB RAM, 100 GB SSD, 8 TB transfer	EUR 4.38/mo (EUR 105.12)	EUR 8.76/mo (EUR 210.24)	EUR 315.36
Contabo Cloud VPS 4	4 vCPU, 8 GB RAM, 100 GB SSD, unmetered	EUR 4.40/mo (EUR 105.60)	published rate: EUR 4.40/mo	EUR 211.20 if it holds

Contabo's box is 33% cheaper over four years on the published rates, with an extra vCPU. The caveat is the whole point of this article: Time4VPS has told you what month 25 costs and Contabo has not. The same Time4VPS box costs EUR 12.99 on a rolling monthly term, so its 24-month rate is a genuine commitment discount rather than a bait rate. The Contabo vs Time4VPS page has the rest of the specs.

Advertised prices barely move

We snapshot every tracked plan nightly. For the 1,030 plans whose history reaches back before 10 June 2026, that is 197,814 individual readings, and 811 of them (78.7%) have shown exactly one price on every single night.

Split by group, the difference is small: 81.0% of single-price plans have never moved, against 74.8% of plans from renewal-publishing hosts. Both groups are dominated by stillness.

Read that carefully, because it is easy to over-claim. Those readings measure the sticker price on a pricing page. They say nothing about what an existing customer is charged at renewal, because a host does not repost your invoice on its homepage. The honest summary is that hosting list prices are far more stable than the industry's discount theatre implies, and that the volatility you actually experience comes from your own contract rolling over rather than from the market repricing around you.

What I would buy for a small WordPress site today

On a four-year horizon, A2 Hosting's Starter plan at \$95.52 total is the cheapest deal among hosts that will tell you their renewal rate, and I would take it over anything else in the shared tier. Hostinger Premium at \$143.52 is the better buy if you need more than one site, and it is the plan I would recommend to somebody who wants a name they have heard of. Both make you pay four years up front, which is the actual trade.

Avoid pairing a 12-month intro term with a 5x or steeper markup unless you have a migration in your calendar. SiteGround StartUp, FastComet Starter and GreenGeeks Lite all cost more over four years than plans with worse-looking multiples, and the reason is always the same: the discount runs out three or four times sooner.

If renewal pricing bothers you as a matter of principle, the metered hosts remove the problem by removing the contract. You give up cPanel, one-click WordPress installs, phone support and somebody else keeping your backups, and for most small sites that is a bad trade. For a developer who already runs their own stack, it is the obvious one. Our VPS hosting and shared hosting category pages are sorted so you can see both worlds against each other.

One last habit worth forming. Before you enter a card, find the renewal rate on the page. If you cannot find it, that is not the same as it not existing, and it is worth two minutes in the host's terms of service to check. All figures here were read from our production database on 7 September 2026 and cover 50 providers.

Originally published at hostingsift.com

AI Crawlers Are Eating Your Hosting Plan: The 2026 Bot Traffic Problem

HostingSift — Mon, 07 Sep 2026 17:41:59 +0000

Updated 21 September 2026. The unmetered VPS table was re-checked against our database on that date. Hetzner's CX23 is no longer sold after its June 2026 repricing, and Contabo replaced its Cloud VPS 10 with the Cloud VPS 4.

Your traffic graph doubled last month. Your revenue did not. Before you celebrate or panic, check the user agents, because there is a good chance most of that "traffic" was GPTBot, ClaudeBot, Amazonbot and a few dozen crawlers you have never heard of, quietly working through every URL you have ever published.

This has stopped being a curiosity and become a line item. Automated requests made up 57.5% of all web traffic by June 2026 according to Cloudflare Radar, up from 53% across 2025, which was already the first calendar year where machines outnumbered people. AI-driven crawling specifically grew roughly 300% year over year.

Two things follow from that, and most site owners only know about one of them. The first is that bots consume the bandwidth, visits and CPU cycles you are paying for. The second is stranger: some hosts have quietly started blocking AI crawlers on your behalf, which protects your bill and erases you from AI answers at the same time. Both of those are decisions you should be making, not discovering.

The short version

Bots are now the majority of web requests. On a small site, AI crawlers routinely account for 30% to 50% of raw bandwidth.
Over half of AI crawler traffic re-fetches pages that have not changed, per Cloudflare's own numbers. You are paying to serve the same article to the same bot repeatedly.
Kinsta stopped counting bad-bot bandwidth against plan limits in November 2025. WP Engine never counted bots as billable visits, but does rate-limit them at the platform level, which is a different trade-off entirely.
Unmetered and high-allowance VPS plans are effectively immune to the cost side. Contabo Cloud VPS 4 gives you 4 vCPU, 8 GB RAM and unlimited traffic for 4.40 EUR/mo.
On 15 September 2026 Cloudflare starts blocking mixed-use AI crawlers by default on ad-bearing pages. If you are on the free tier, that default lands on you whether you asked for it or not.

How much traffic are we actually talking about?

The numbers are worse than the abstraction suggests. In a single 24-hour window, bots hit add-to-cart URLs on WordPress sites 7.67 million times. ClaudeBot alone was responsible for about 3.75 million of those. Add-to-cart is the single most expensive request a WooCommerce site can serve: uncacheable, database-heavy, session-creating. Bots were hammering it millions of times a day for no commercial reason whatsoever.

One crawler in a documented case generated 550 million requests over 30 days against a single property before anyone stopped it. That is not a traffic spike, that is a sustained load test you did not order and cannot invoice anyone for.

The waste is what stings. Cloudflare found that more than half of AI crawler traffic is re-fetching content that has not changed since the last visit. Your 2023 blog post gets pulled down again and again, at your expense, so a model can confirm it still says what it said last week.

Four ways your host makes you pay for it

1. Visit-metered plans

Premium managed WordPress hosting has historically sold capacity in "visits". The definition matters enormously here. WP Engine counts one visit as one unique IP address per day, and explicitly excludes known and suspected bot user agents, plus requests that only touch static assets. Kinsta filters most well-known bot user agents out of its visit counts too, though it acknowledges that bots which do not identify themselves still consume server resources and may slip into the total.

That exclusion is doing a lot of load-bearing work. A crawler that identifies itself politely as GPTBot is free. A scraper rotating residential IPs with a Chrome user agent is indistinguishable from a reader, and it counts.

Provider	Entry plan	Price/mo	Allowance	Storage	Sites
Rocket.net	Starter	$25.00	50 GB bandwidth	10 GB NVMe	1
Kinsta	Single 35k	$29.17	35,000 visits/mo	10 GB	1
Kinsta	Single 20GB	$29.17	20 GB bandwidth	10 GB	1
WP Engine	Essential	$28.00	75 GB bandwidth	10-50 GB	1
Cloudways	Autonomous Growth	$99.00	150 GB bandwidth	20 GB	1

Look at the Kinsta rows. Same price, two different meters: 35,000 visits or 20 GB of bandwidth. That choice exists precisely because bot traffic broke the visit model. Kinsta announced on 4 November 2025 that bandwidth consumed by unwanted bots and scrapers no longer counts against plan limits, and gave customers the option to pick whichever meter suits their traffic shape. If your audience is small but your content is heavily crawled, visits are the safer unit. If you serve large media to few people, bandwidth is.

Also note how tight these allowances are in absolute terms. WP Engine's Essential plan includes 75 GB of bandwidth for $28/mo. A determined crawl of a media-heavy site can eat that in days. Compare the same $30 against a VPS plan and you are looking at multiple terabytes.

2. "Unlimited" shared hosting

Shared hosts do not meter your bandwidth, so on paper bots are free. In practice they meter something else: CPU seconds, entry processes, I/O operations, inodes. A crawler that requests 40,000 uncached PHP pages in an afternoon does not blow a bandwidth cap, it blows your CPU quota, and the account gets throttled or suspended. The bill arrives as an upgrade prompt rather than an overage line.

Provider	Plan	Intro price	Renewal	Bandwidth	Storage
ChemiCloud	Starter	$1.95/mo	$11.95/mo	Unlimited	20 GB NVMe
NameHero	Starter Cloud	$2.91/mo	$11.64/mo	Unmetered	25 GB NVMe
GreenGeeks	Lite	$2.95/mo	$13.95/mo	Unmetered	25 GB SSD
Hostinger	Premium	$2.99/mo	$10.99/mo	Unlimited	20 GB SSD

We have written before about what "unlimited" hosting really means. Bot traffic is the fastest way to find out for yourself.

3. Metered egress on cloud platforms

This is the model where a crawl storm turns into a genuinely alarming invoice. Platforms that bill per gigabyte of egress charge the same for a bot as for a customer. There is no bot exclusion, because there is no concept of a visit at all, just bytes leaving the network. We covered the mechanics in detail in bandwidth overage and CDN pricing traps, and AI crawlers have made that article age faster than we expected.

4. Nothing, because your plan has headroom

The unglamorous answer to the whole problem is buying a plan where the traffic simply does not matter. Unmetered European VPS providers charge a flat monthly fee and do not care whether the bytes went to a reader in Berlin or a datacenter in Oregon.

Provider	Plan	Price/mo	Bandwidth	CPU	RAM	Storage
Time4VPS	Linux 2	2.88 EUR	4 TB	1 core	2 GB	25 GB SSD
InterServer	1 Slice	$3.00	2 TB	1 core	2 GB	40 GB SSD
Contabo	Cloud VPS 4	4.40 EUR	Unlimited	4 vCPU	8 GB	100 GB SSD
Hostwinds	Unmanaged SSD Cloud 1	$4.99	1 TB	1 vCPU	1 GB	30 GB SSD
NameHero	Starter VPS	$5.44	4 TB	1 core	4 GB	80 GB NVMe
netcup	VPS 500 G12	5.91 EUR	Unlimited	2 vCPU	4 GB	128 GB NVMe
Hetzner	CPX12	11.49 EUR	20 TB	1 vCPU	2 GB	40 GB NVMe

Contabo and Hetzner list prices before VAT. netcup's price includes 19% German VAT and assumes a 12-month term.

Contabo at 4.40 EUR with unlimited traffic and 8 GB of RAM is the single most bot-proof entry on this page. Hetzner's 20 TB allowance is functionally unlimited for any site that is not distributing video, but its cheapest plan now costs 11.49 EUR after the June 2026 repricing. The trade-off is that you now run the server, which is real work. Our managed vs unmanaged VPS breakdown covers whether that trade is worth it for you, and Hetzner vs Netcup settles the European price fight.

The part nobody warned you about: your host may already be blocking AI bots

Here is where it gets genuinely interesting, and where the cost conversation flips into a visibility conversation.

Testing published in April 2026 found that WP Engine enforces platform-level rate limiting on high-impact crawlers. ClaudeBot requests were rate-limited (HTTP 429) 29% of the time, GPTBot 29%, and Amazonbot 51%. WP Engine support confirmed the behaviour, describing it as protection for overall server performance, and stated it cannot be selectively disabled per bot.

Other managed platforms went the other way. Kinsta's CTO said in March 2026 that Kinsta will not block at the platform level. Pressable's documentation states it does not disallow these bots by default. Pantheon states plainly that it does not block identified bot traffic from entering the platform.

Platform	Blocks AI crawlers by default?	Bot traffic billed?
WP Engine	Yes, platform-wide rate limiting on high-impact bots, not disableable per bot	No, known bots excluded from billable visits
Kinsta	No, stated policy against platform-level blocking	No, bad-bot bandwidth excluded since Nov 2025
Pressable	No, per published documentation	Visit-based plans
Pantheon	No, explicitly does not block identified bots	Visit-based plans
Self-managed VPS	Only what you configure	Only if your plan is metered

Why does that matter beyond principle? Because on the same test property, access rate and citation rate tracked each other closely. GoogleBot had roughly 100% access and the site appeared in 37.8% of Google AI Mode responses. PerplexityBot had 100% access and 7.8% citation presence. ClaudeBot, at 57% access, produced a 0.0% citation rate in Claude.

That is one site, one test window, and correlation is not proof. But the direction is not subtle. Where the crawler can read you, the model cites you. Where it cannot, you are absent from an answer surface that is quietly taking a growing share of the queries that used to become clicks.

So the decision is not "bots bad, block them". It is a trade you should make deliberately: pay a little bandwidth to stay in the index that increasingly mediates discovery, or save the bandwidth and accept invisibility. Choosing by accident, because your host set a default you never saw, is the only genuinely wrong answer.

What changes on 15 September 2026

Cloudflare has been escalating this since it became the first major infrastructure provider to block AI crawlers by default. As of 15 September 2026, mixed-use crawlers, the ones that blend search indexing with AI training and agentic browsing, get blocked by default on pages that carry ads. The default applies to new Cloudflare customers, new sites added by existing customers, and every site on the free tier.

If you run an ad-supported site behind Cloudflare's free plan, that switch flips for you automatically. Worth knowing before it happens rather than after your AI referral traffic quietly flatlines.

Cloudflare has also moved from Pay Per Crawl to Pay Per Use, which pays publishers when their content is actually used in an answer rather than merely fetched. Good idea in principle. In practice it is early, partner-limited, and not something a site doing 5,000 visits a month should be building a strategy around.

What to actually do this week

Look at your logs before you change anything. Filter by user agent and count requests and bytes for GPTBot, ClaudeBot, PerplexityBot, Amazonbot, Bytespider, CCBot and Meta-ExternalAgent. Until you know your split, everything else is guesswork.
Find out whether your host is already blocking. Ask support directly: do you rate-limit or block AI crawlers at the platform level, and can I opt out? On WP Engine the answer is yes and no respectively. Do not assume your robots.txt is the only thing in play.
Decide per crawler, not globally. Training crawlers that never send referrals are a different proposition from retrieval crawlers that cite sources with links. Blocking GPTBot and allowing OAI-SearchBot is a coherent position. Blocking everything with a wildcard usually is not.
Put caching in front of the problem. A crawler hitting a full page cache costs you bytes and nothing else. The same crawler hitting uncached PHP costs you CPU, database queries and the throttling that follows. This is the single highest-leverage fix on shared hosting.
Rate-limit rather than ban. A crawl-delay or an edge rate limit keeps you in the index while capping the damage. A hard 403 removes you from it.
Protect the expensive endpoints specifically. Cart, checkout, search, faceted filters, calendar pages. Those are where 7.67 million daily bot hits become someone's downtime.
If bots are more than a third of your bandwidth, reprice. Run the numbers through our true cost calculator. Paying $30/mo for 75 GB while crawlers eat 25 GB of it is a worse deal than 5.91 EUR for unmetered traffic at netcup.

Our recommendation, by situation

Small WordPress site, non-technical owner. Stay on shared hosting, turn on full-page caching, and add a crawl-delay. Hostinger Premium at $2.99 intro and $10.99 on renewal is fine until bots become a CPU problem rather than a bandwidth one.

Content site that depends on being found. Do not host anywhere that blocks AI crawlers for you. That points at Kinsta among the premium managed options, and the bandwidth-metered plan rather than the visits one now that bad-bot traffic is excluded. See Kinsta vs WP Engine for the wider comparison.

WooCommerce store. Your cart endpoints are the target. Get proper edge caching, rate-limit uncacheable paths, and pick a host with real CPU headroom rather than a generous bandwidth number. WooCommerce hosting is worth the premium here.

Developer or agency running your own stack. Take the unmetered VPS and stop thinking about it. Contabo at 4.40 EUR or netcup VPS 500 G12 at 5.91 EUR removes the cost side of the problem entirely, leaving you to make the visibility decision on its own merits. Browse cloud hosting and VPS hosting for the full list.

Bottom line

AI crawlers turned a rounding error into a budget line and a distribution question at the same time. The cost half is solvable with cheap infrastructure: unmetered European VPS plans start at a few euros a month and make the whole conversation moot. The visibility half is not solvable with money, only with an explicit decision about who gets to read your content.

The worst position is the common one: on a metered plan, with a host quietly rate-limiting crawlers you never evaluated, paying for bot bandwidth while disappearing from the answers those bots feed. Check your logs, ask your host the direct question, and pick your side on purpose.

Prices in this article come from the HostingSift database and were current in August 2026. Intro prices are promotional; renewal rates are listed where they differ. Third-party statistics are attributed inline and reflect published figures as of mid-2026.

Originally published at hostingsift.com

VPS Price Per GB of RAM: 711 Plans Across 39 Hosts

HostingSift — Mon, 31 Aug 2026 11:32:21 +0000

A gigabyte of RAM on a virtual server costs \$0.47 per month. It also costs \$58.00 per month. Same unit, same billing period, both prices live on 31 August 2026.

We priced every plan in our database that publishes a RAM figure: 711 active VPS and cloud plans from 39 providers, EUR prices converted to USD, everything normalised to dollars per gigabyte per month. The median came out at exactly \$6.00. Half the market sits above that line, half below, and the distance between the two ends is 123x.

That spread is not a mistake, and it is not all margin either. But it is far wider than most buyers assume, and the reason it stays wide is that almost nobody prices RAM by the gigabyte when they shop. They look at the plan name and the monthly figure.

How we counted

Every number here comes from our nightly price readings, taken on 30 and 31 August 2026. The rules we applied:

Only plans currently active and in stock, with both a price and a stated RAM figure. VPS and cloud categories, no shared hosting, no dedicated metal.
Prices converted to USD at our stored rate for the eight EUR-billed hosts in the set (Contabo, Hetzner, Netcup, OVHcloud, Private Hosting, Diploi, Evolution Host, Time4VPS).
Monthly-equivalent pricing. A 24-month Contabo term shows as its per-month figure, which is how the provider advertises it.
Railway's Pro plan is excluded. Its 1 TB figure is an account ceiling rather than provisioned memory, and including it would have handed the crown to a plan that does not give you a 1 TB server.
Fly.io's storage and bandwidth are usage-based and not counted against the RAM price.

The cheapest gigabyte at each host

For every provider we took its single best plan by dollars per GB, then looked up what that same plan renews at. The renewal column is where the ranking falls apart.

Provider	Best plan	RAM	Price/mo	\$/GB intro	\$/GB renewal
Contabo	Cloud VPS 18	96 GB	\$45.08	\$0.47	\$0.47
Time4VPS	Container C16	16 GB	\$8.06	\$0.50	\$1.01
NameHero	Business VPS	32 GB	\$20.68	\$0.65	\$1.50
IONOS	VPS XL+	16 GB	\$11.00	\$0.69	\$2.75
OVHcloud	VPS-6 2026	96 GB	\$71.35	\$0.74	\$0.74
Hostinger	KVM 4	16 GB	\$12.99	\$0.81	\$1.81
Netcup	VPS 8000 G12	64 GB	\$55.14	\$0.86	\$0.86
HostGator	Snappy 2000 NVMe 4	4 GB	\$4.18	\$1.04	\$2.34
HostArmada	Unmanaged Ignition	16 GB	\$16.89	\$1.06	\$2.64
DreamHost	Stack 16	16 GB	\$17.49	\$1.09	\$1.66
ServaRica	NVMe Cheetah	6 GB	\$7.00	\$1.17	\$1.17
InMotion Hosting	VPS 8 vCPU	16 GB	\$19.99	\$1.25	\$3.56
Private Hosting	VPS-RAM-64GB	64 GB	\$91.99	\$1.44	\$1.44
InterServer	1 Slice	2 GB	\$3.00	\$1.50	\$1.50
Bluehost	NVME 8	8 GB	\$12.99	\$1.62	\$3.62
A2 Hosting	Self Managed Linux L	32 GB	\$54.98	\$1.72	\$3.44
GoDaddy	32 vCPU / 128 GB	128 GB	\$219.99	\$1.72	\$2.66
Namecheap	Hypernova	24 GB	\$46.88	\$1.95	\$2.20
LiquidWeb	VPS 4GB (Self-Managed)	4 GB	\$8.50	\$2.12	\$4.25
Linode	High Memory 24GB	24 GB	\$60.00	\$2.50	\$2.50

Below that group the numbers climb quickly. AWS Lightsail's best memory ratio is \$4.50/GB, Hetzner's cloud line \$4.67, Vultr \$5.00, DigitalOcean \$5.25. Cloudways cannot get under \$9.66 and SiteGround's cloud entry point works out at \$12.50 per GB.

Contabo taking first place surprises nobody who has shopped European VPS before. What surprises people is second place: Time4VPS, a Lithuanian host most buyers have never heard of, selling 16 GB containers for \$8.06 a month. Its catch is in the renewal column, where the price doubles.

Renewal reshuffles the whole board

Twelve of the 39 hosts charge exactly what they advertise, forever. The rest use an intro rate, and the size of the step varies enormously.

IONOS runs the steepest one in the set. VPS XL+ is the fourth cheapest gigabyte in the market at signup and drops to sixteenth once the first year ends, because \$11.00 becomes \$44.00. That is a 4x step on a plan whose specs do not change. IONOS is far from alone: InMotion Hosting moves from twelfth to twenty-first, HostArmada from ninth to seventeenth, A2 Hosting from sixteenth to twenty-second.

Movement runs the other way too. OVHcloud is fifth cheapest at signup and second cheapest at renewal. Netcup goes from seventh to third. InterServer, whose flat \$1.50 per GB looks unremarkable next to Contabo's \$0.47, climbs from fourteenth to eighth simply by not raising anything.

Provider	Rank at signup	Rank at renewal	Move
OVHcloud	5	2	+3
Netcup	7	3	+4
ServaRica	11	5	+6
InterServer	14	8	+6
Time4VPS	2	4	-2
NameHero	3	9	-6
HostArmada	9	17	-8
InMotion Hosting	12	21	-9
IONOS	4	16	-12

Contabo holds first place in both columns. So does its price, which is the entire argument for buying there.

If you want to see what a specific step costs you over a full term rather than a month, our true cost calculator does that arithmetic, and we went deeper on the pattern in monthly vs annual vs 3-year plans.

What 8 GB actually costs, host by host

Ratios are useful for ranking. For a buying decision you want a fixed basket, so here is the same question asked concretely: what does an 8 GB server cost, and what else comes with it?

Provider	Plan	vCPU	Storage	Price/mo	Renews at
Time4VPS	Container C8	3	100 GB SSD	\$5.04	\$10.07
Contabo	Cloud VPS 4	4	100 GB SSD	\$5.06	\$5.06
IONOS	VPS L+	4	240 GB NVMe	\$6.00	\$21.00
OVHcloud	VPS-1 2026	4	75 GB NVMe	\$6.35	\$6.35
NameHero	Plus VPS	2	100 GB NVMe	\$6.85	\$15.92
HostGator	Snappy 4000 NVMe 8	4	200 GB NVMe	\$8.36	\$18.70
Hostinger	KVM 2	2	100 GB NVMe	\$8.99	\$14.99
DreamHost	Stack 8	2	150 GB NVMe	\$10.99	\$16.99
Netcup	VPS 1000 G12	4	256 GB NVMe	\$11.93	\$11.93
InterServer	4 Slices	2	160 GB SSD	\$12.00	\$12.00
Bluehost	NVME 8	4	200 GB NVMe	\$12.99	\$28.99
Private Hosting	VPS-RAM-8GB	2	50 GB NVMe	\$14.94	\$14.94
A2 Hosting	Self Managed Linux S	4	160 GB NVMe	\$19.99	\$39.99
LiquidWeb	VPS 8GB Self-Managed	4	240 GB SSD	\$22.50	\$45.00
Vultr	CC Regular 4vCPU/8 GB	4	160 GB SSD	\$40.00	\$40.00
Hetzner	CPX32	4	160 GB NVMe	\$40.81	\$40.81
DigitalOcean	Basic Regular 8 GiB	4	160 GB NVMe	\$48.00	\$48.00
Linode	Shared Linode 8GB	4	160 GB SSD	\$48.00	\$48.00
Cloudways	DO Basic Large	4	160 GB NVMe	\$99.00	\$99.00
SiteGround	Jump Start	4	40 GB SSD	\$100.00	\$100.00

Look at the bottom four rows against the top four. Cloudways charges \$99 for a DigitalOcean droplet that DigitalOcean sells for \$48, and the \$51 difference is the managed layer: patching, staging, a control panel, support that answers. Whether that is worth 2x depends entirely on how many hours of your own time you were planning to spend on server administration. We took that question apart in managed vs unmanaged VPS.

SiteGround's Jump Start is the one row that resists any justification on the numbers. \$100 for 8 GB and 40 GB of disk is 20x Contabo's rate for the same memory and less than half the storage.

Bigger boxes do not get you cheaper RAM

Standard intuition says memory gets cheaper per gigabyte as you scale up. Across the whole market that intuition is wrong.

RAM size	Plans	Median \$/GB	Cheapest \$/GB
Under 4 GB	104	\$7.14	\$1.45
4 GB	89	\$6.50	\$0.83
8 GB	105	\$6.00	\$0.63
16 GB	102	\$5.99	\$0.50
32 GB	79	\$5.81	\$0.65
64 GB	53	\$6.09	\$0.53
96 GB and up	91	\$6.91	\$0.47

The median barely moves from 4 GB to 64 GB, and at the top of the ladder it goes back up. Meanwhile the cheapest available rate keeps falling. Both facts are true because the volume discount is real inside certain hosts and absent at others, and the ones without it dominate the large-plan population.

Ranked by how much cheaper a provider's largest plan is per gigabyte than its smallest:

Provider	Smallest plan \$/GB	Largest plan \$/GB	Discount
Private Hosting	\$5.74 (1 GB)	\$1.44 (64 GB)	4.0x
HostArmada	\$3.69 (1 GB)	\$1.06 (16 GB)	3.5x
Time4VPS	\$5.10 (0.5 GB)	\$1.60 (64 GB)	3.2x
OVHcloud	\$2.02 (2 GB)	\$0.74 (96 GB)	2.7x
Contabo	\$1.26 (4 GB)	\$0.47 (96 GB)	2.7x
GoDaddy	\$4.50 (2 GB)	\$1.72 (128 GB)	2.6x
Hostinger	\$1.62 (4 GB)	\$0.81 (32 GB)	2.0x
DigitalOcean	\$8.00 (0.5 GB)	\$6.19 (384 GB)	1.3x
InterServer	\$1.50 (2 GB)	\$1.50 (16 GB)	1.0x
Vultr	\$5.00 (0.5 GB)	\$5.00 (256 GB)	1.0x
SiteGround	\$12.50 (8 GB)	\$20.00 (20 GB)	0.6x
Kamatera	\$4.00 (1 GB)	\$7.88 (8 GB)	0.5x
Fly.io	\$7.76 (256 MB)	\$15.50 (32 GB)	0.5x

Vultr and InterServer sell memory at a perfectly linear rate. Their pricing pages are honest in a way that makes comparison shopping trivial, and it means there is zero reward for over-provisioning.

The last three rows are the interesting ones. At Kamatera, Fly.io and SiteGround, scaling up costs you more per gigabyte, not less. Fly.io's Performance tier at \$15.50 per GB against its own \$7.76 shared tier is a dedicated-vCPU premium, which is the honest explanation. It is still a price signal worth reading before you scale a Fly app upward on autopilot.

Why cheap RAM is cheap

Contabo's \$0.47 and DigitalOcean's \$5.25 are not the same product wearing different price tags. Four things account for most of the gap.

CPU allocation. Budget hosts oversubscribe cores heavily. Contabo's 96 GB plan comes with 24 shared vCPU on EPYC silicon and you will feel the neighbours under sustained load. Hetzner's CCX line and Vultr's Optimized range give you dedicated cores, which is why their per-GB numbers look terrible. They are not selling you memory. Memory is a side effect of selling you a core.

Network. Contabo, Netcup and OVHcloud market unlimited or unmetered transfer at consumer speeds. DigitalOcean and Linode meter it precisely and charge overages. Our data shows Hostinger's KVM 4 including 16 TB of transfer while Vultr's 8 GB plans cap at 5 to 6 TB.

Support. A \$5 Contabo ticket goes into a queue. LiquidWeb answers in minutes and staffs Linux engineers around the clock. That difference is roughly half the price of a managed plan.

Recovery time when something breaks. This one never shows up in a spec table and matters more than the rest combined once you are hosting anything that earns money.

None of that makes \$12.50 per GB defensible at SiteGround. It does make \$5.25 per GB defensible at DigitalOcean if you use the API, the managed databases and the load balancers that come with it. Choose the tier that matches how you actually operate, then compare inside it: Contabo against OVHcloud for the European budget end, DigitalOcean against Hostinger when you are weighing a developer cloud against a value VPS.

These prices barely move

We have been recording VPS prices every night since 12 February 2026, which lets us answer a question nobody else can: how stable is any of this?

Very. Of the 185 plans in this analysis that we have been reading since mid-February, 165 have shown the same price on every single nightly reading. That is 89% of the sample frozen for six and a half months.

The stability is concentrated at the top of the market. DigitalOcean has not changed a single price on any of its 90 plans since we started watching. Linode has not moved on 39 plans, AWS on 25, Hostwinds on 40, Cloudways on 60. OVHcloud's entire 41-plan catalogue has held since we picked it up on 1 April 2026.

The movers are mostly budget and mid-market hosts:

Hostinger, 3 March 2026. KVM 4 went from \$9.99 to \$12.99 and has read \$12.99 on every night since, 133 readings through 30 August. The renewal price moved first, from \$24.99 to \$28.99 on 27 February, which is the pattern we keep seeing: the invoice rises before the storefront does.
Netcup, 4 June 2026. VPS 8000 G12 went from about \$42 to \$55 in USD terms, roughly 24%, and has held on all 86 readings since.
IONOS, 20 June 2026. The old VPS line was retired and replaced with the "+" range on yearly billing. Intro prices fell and renewals rose. VPS L+ has read \$6.00 renewing at \$21.00 on all 74 nights since.

Hetzner repriced its cloud range in mid-2026 and it is no longer the cheap default it was for a decade. Our own chart for it splits at 13 August 2026 for a data reason we document on the provider page, so treat the older part of that series as catalogue history rather than a clean nightly series.

The practical takeaway from all this stillness: a good price today will still be a good price when you get round to migrating. The risk is not that the market moves under you. The risk is your own renewal date.

What I would actually buy

Running a side project or a staging box, under \$10 a month. Contabo Cloud VPS 4 at \$5.06 for 8 GB, or OVHcloud VPS-1 at \$6.35 if you want a European provider whose price will not double. Both renew at what they advertise. Skip Time4VPS's \$5.04 here despite it topping the table, because the renewal doubles and 8 GB is not enough headroom to make the migration worth deferring.

Production WordPress or a small SaaS, 8 to 16 GB. Netcup VPS 1000 G12 at \$11.93 flat, or InterServer at \$12.00 flat if you want US datacentres and per-slice scaling. Hostinger KVM 4 gives you 16 GB for \$12.99, which is the best headroom per dollar in the set, but budget for \$28.99 when the two-year term ends. Worth comparing directly: Netcup against OVHcloud and Contabo against Hostinger.

You want an API, snapshots and managed databases. DigitalOcean or Vultr at around \$5 per GB. You are paying roughly 8x Contabo's rate for the ecosystem, and for a team shipping weekly that maths usually works.

You do not want to touch a server. Cloudways at \$99 for 8 GB. Expensive per gigabyte and correctly priced for what it removes from your week.

Avoid on the numbers. SiteGround's cloud tier at \$12.50 per GB, and any IONOS VPS bought without a calendar reminder for month twelve.

The full set of plans behind this analysis is browsable on our VPS hosting and cloud hosting pages, with the nightly price history attached to each provider profile. If you are still deciding whether you need any of this, when to upgrade from shared hosting is the earlier question.

Prices recorded 31 August 2026 from our nightly readings. EUR converted to USD. Monthly-equivalent figures; several budget plans require a 24-month commitment to hit the advertised rate.

Originally published at hostingsift.com.

ARM VPS Hosting in 2026: More Cores for Less Money

HostingSift — Fri, 28 Aug 2026 06:22:53 +0000

Updated 21 September 2026. Both European ARM lines this article recommends are currently unavailable. netcup shows its ARM range as sold out, and Hetzner's CAX plans are no longer in its price list after its June 2026 repricing. The netcup ARM prices below are the last ones listed, kept for reference. Until the lines come back, the x86 alternatives in the recommendation section are what you can actually order.

ARM processors are no longer just the chip in your phone. By 2026 they power a serious chunk of cloud infrastructure, and the most interesting part is that they have reached VPS plans at prices that make classic x86 servers look overpriced. Pick the right provider and you get more cores, lower power draw, and a bill that is dramatically smaller than what the American clouds charge.

This is a practical look. Real plans, real prices from our VPS hosting database (current as of June 2026), and an honest answer to when ARM is the better choice and when it still pays to stay on x86.

The short version

An ARM VPS is a virtual server running on an ARM chip (usually Ampere Altra) instead of a classic Intel or AMD one.
The best value in Europe came from Netcup and Hetzner, but as of 21 September 2026 neither sells ARM plans. When netcup's ARM plans were on sale, they gave you more cores for less money than its own x86 plans.
Netcup VPS 1000 ARM: 6 vCPU, 8 GB RAM, 256 GB NVMe for 7.77 EUR per month when available. The equivalent x86 plan, which you can order today, costs 10.37 EUR.
Against the American clouds the gap is drastic, even on x86. A 4 GB RAM plan at netcup costs 5.91 EUR today, while the same class at AWS Lightsail, Linode and Vultr runs between 20 and 24 USD.
ARM is excellent for web servers, containers, databases, CI/CD and Go or Node apps. Be more careful with legacy software that only ships x86 binaries.
ARM chips draw less power per unit of performance, so it is also the greener choice.

What ARM hosting actually is and why it is suddenly everywhere

For years servers were almost entirely x86 from Intel and AMD. ARM was for mobile devices because it sips power. Then Amazon launched Graviton, Ampere shipped Altra chips with dozens of cores, and cloud providers discovered something pleasant: ARM servers deliver comparable performance at lower power draw and a lower cost per core.

By 2026 that wave has reached the ordinary VPS market. Ampere Altra machines with up to 80 cores are being sliced into virtual plans you can rent for the price of a coffee. The software ecosystem has caught up too. Almost everything important now has an ARM64 build: the Linux distributions, Docker images, Node, Python, Go, PostgreSQL, MySQL, Nginx, Redis. That is exactly what was missing three years ago, and exactly why ARM is now a real option rather than an experiment.

ARM vs x86: the real price-per-resource comparison

The best way to feel the difference is to put ARM and x86 plans from the same provider side by side. Here is how it looks at Netcup, where the effect is clearest.

Plan	Architecture	vCPU	RAM	NVMe	Price/mo
VPS 1000 ARM G11	ARM (Ampere)	6 vCPU	8 GB	256 GB	7.77 EUR
VPS 1000 G12	x86	4 vCPU	8 GB	256 GB	10.37 EUR
VPS 2000 ARM G11	ARM (Ampere)	10 vCPU	16 GB	512 GB	13.41 EUR
VPS 2000 G12	x86	8 vCPU	16 GB	512 GB	19.25 EUR

netcup lists these prices including 19% German VAT. The ARM rows show the last listed prices, since the ARM range was sold out on 21 September 2026.

Read that table again. At every tier the ARM plan has more cores, the same memory, the same disk space, and costs 25 to 30 percent less. This is not a marketing trick, it is a direct consequence of cheaper hardware. ARM cores are smaller and cheaper to manufacture, so the provider can pack more of them into a plan and still sell it for less.

Hetzner CAX: the pure Ampere line

Hetzner brands its ARM plans as CAX. They run on Ampere Altra with shared vCPUs. After Hetzner's June 2026 repricing, the CAX plans are no longer in its price list, so you cannot order them at the moment.

Plan	vCPU	RAM	NVMe	Status
CAX11	2 vCPU	4 GB	40 GB	Not currently offered
CAX21	4 vCPU	8 GB	80 GB	Not currently offered
CAX31	8 vCPU	16 GB	160 GB	Not currently offered
CAX41	16 vCPU	32 GB	320 GB	Not currently offered

When the line was on sale, it undercut Hetzner's own shared x86 plans of the same size. Those x86 plans are now expensive: the CPX42 with 8 vCPU and 16 GB costs €69.49 a month excluding VAT. If Hetzner brings CAX back, our Hetzner price history will show it.

Netcup ARM G11: the most cores for the money

If you are chasing the maximum number of cores, Netcup ARM is hard to beat. VPS 8000 ARM gave 18 vCPU, 64 GB RAM and 2 TB NVMe for around 40 EUR per month before the range sold out. That is a resource density that would cost a four-figure bill at the American providers. It is also why Netcup is a favourite among people running databases, self-hosted apps and heavy container stacks.

How much cheaper it is than the American clouds

Here the difference stops being percentages and becomes a multiple. We take a 4 GB RAM class and put a European plan you can order today next to the familiar American names we track in our database.

Provider	Plan	vCPU	RAM	Storage	Price/mo
netcup (x86)	VPS 500 G12	2 vCPU	4 GB	128 GB NVMe	5.91 EUR incl. VAT
Vultr	Cloud Compute 4 GB	2 vCPU	4 GB	80 GB SSD	20.00 USD
Amazon Lightsail	4 GB / 2 vCPU	2 vCPU	4 GB	80 GB SSD	24.00 USD
Linode	Shared 4GB	2 vCPU	4 GB	80 GB SSD	24.00 USD
DigitalOcean	Basic 4 GB	2 vCPU	4 GB	80 GB NVMe	24.00 USD

Note: the European price is in euros, the American ones in dollars. For reference, 24 USD is roughly 21 EUR at September 2026 rates, so the gap stays a multiple.

Same memory class, yet the European bill is roughly three times smaller, and that is on x86. When the ARM plans were on sale, the gap was wider still. Part of the difference comes from European budget providers being more aggressive on price than the hyperscalers, not only from the architecture. But the architecture helps. Among the American providers, AWS now offers its own ARM chips (Graviton), which are usually 10 to 20 percent cheaper than the x86 equivalent, confirming the same trend.

Before you fall in love with the lowest price, run your real scenario through our true cost calculator. The monthly price is one thing, but traffic, backups and add-on services change the picture.

What ARM is great for and what it is not

ARM is not a universal replacement. It shines on some workloads and creates headaches on others. Here is the honest breakdown.

Where ARM works brilliantly

Web servers and APIs. Nginx, Caddy, Node, Go, PHP, Python. All of these have mature ARM64 builds and run with no noticeable difference.
Containers. Docker and Kubernetes have supported ARM64 for a long time. Most popular images are multi-arch, so they pull the right version automatically.
Databases. PostgreSQL, MySQL, MariaDB and Redis run great on ARM, and the high core counts at Netcup help with parallel queries.
CI/CD and build machines. More cores per euro means faster builds, especially for Go and Rust projects that use every core.
Self-hosted apps. Nextcloud, Gitea, n8n, Vaultwarden and the like have official ARM images.

Where x86 is still worth it

Legacy software with x86-only binaries. Some closed corporate apps, old plugins or specific drivers have no ARM build. Check before you migrate.
Software with heavy x86 assembly optimizations. Rare cases, but they exist. Test performance, do not assume anything.
When your team has no time to test. If your stack has been x86 for years and everything works, the migration is a time cost you have to justify with real savings.

Energy efficiency and the green angle

ARM chips are designed to deliver maximum performance per watt. That started as a phone-battery advantage, but in the data center it turns into less power burned for the same work. Less power means a lower carbon footprint per request and lower operating costs, part of which comes back to you as a cheaper plan.

If sustainability is a factor in your choice, ARM hosting fits naturally. It is not a marketing sticker, it is a consequence of the architecture. Combine an ARM server with a provider that uses renewable energy and you get a serious cut in footprint without compromising performance.

How to migrate to ARM without pain

The transition is easier than most people expect, as long as you approach it methodically.

Inventory your stack. List every piece of software you run. For each one, check whether an ARM64 build exists. For mainstream things the answer is almost always yes.
Use multi-arch Docker images. If you are already on containers, most official images are multi-arch and the move is nearly seamless. You just run the stack on an ARM host.
Test on a cheap plan first. Grab the smallest ARM plan you can find, deploy the app and run a load test. The cost of the experiment is symbolic. With both European ARM lines sold out as of 21 September 2026, an hourly-billed ARM instance from a larger cloud is the quickest way to test in the meantime.
Compare real performance. Do not look only at benchmarks. Measure response time and throughput of your own application under real load.
Migrate gradually. Move the non-critical services first. Once you are convinced, move production too.

If you are also considering self-hosting AI models on a budget server, read our guide to running local LLMs on a VPS under 5 dollars. Many of the same ARM considerations apply there.

Our recommendation

For most people who want the best value from an ARM VPS in 2026, the choice comes down to two providers. As of 21 September 2026, neither can sell you one: netcup's ARM range is sold out and Hetzner's CAX line is missing from its price list. In the meantime, netcup's x86 VPS 1000 G12, with 4 vCPU, 8 GB and 256 GB NVMe for €10.37 including VAT on a 12-month term, is the closest thing you can buy.

Pick Netcup if you are chasing the maximum number of cores and disk space for your money. When available, their ARM plans literally beat their own x86 plans on value, and the higher tiers offer a resource density that is hard to match in Europe.

Pick Hetzner if you value a clean interface, hourly billing and a mature cloud ecosystem with snapshots, networks and load balancers. When it returns, the CAX line is ideal for container workloads.

And if you are tied to an American cloud because of a specific region or integration, check whether your provider offers ARM instances and compare them with the x86 equivalent. You will almost always save something. For the full picture, browse our cloud hosting and VPS categories.

Frequently asked questions

Is an ARM VPS slower than x86?

Not in any way you will notice on a typical web or application workload. A single ARM core on Ampere Altra is comparable to an x86 core for most tasks, and because you get more cores for the same money, total performance is often higher. Exceptions exist for very specific single-thread or x86-optimized workloads.

Will WordPress run on ARM hosting?

Yes, completely. PHP, MySQL or MariaDB, Nginx and Redis all have ARM builds. WordPress does not even know what architecture it runs on. This holds for most popular plugins too, because they are PHP rather than compiled binaries.

Can I run Docker on an ARM VPS?

Yes. Docker has supported ARM64 for years. Most official images are multi-arch and automatically pull the right version. If you build your own images, just make sure the base image has an ARM64 variant.

Why is European ARM so much cheaper than the American clouds?

Two reasons combine. First, European budget providers like netcup are generally more aggressive on price than the hyperscalers. Second, ARM hardware is cheaper per unit of performance, so they put more cores in a plan and still sell it for less.

Who is an ARM VPS not right for?

Teams that depend on closed software with x86-only binaries, or who have no resources to test the migration. If your stack is fully open and containerized, the benefits almost always win.

The takeaway for 2026 is simple. ARM is no longer an experiment but a mature, cheaper way to run almost any modern web application. Start with a plan for a few euros, run a real test, and see whether your bill has any reason to stay this high.

Originally published at hostingsift.com.

MCP Server Hosting: Where to Actually Deploy in 2026

HostingSift — Fri, 21 Aug 2026 15:42:03 +0000

Updated 21 September 2026. The VPS prices and platform limits below were re-checked against our database and the providers' own pages on that date. Hetzner's budget CX and CAX plans are no longer sold after its June 2026 repricing, and Vercel's function limits are much longer than the 10 seconds this article first quoted.

Model Context Protocol went from "Anthropic curiosity" to "thing every AI tooling vendor implements" in roughly twelve months. If you build agentic apps in 2026, you almost certainly need to host an MCP server somewhere. The official docs cover the protocol. They do not cover the boring infrastructure question: where does this thing actually run, and what does it cost?

This guide answers that. We will look at the three deployment modes (stdio, HTTP, SSE), the security gotchas that bite teams in production, and the actual hosting price points for running MCP servers at scale. Real plans, real numbers from providers in our database.

What an MCP server is, in one paragraph

Model Context Protocol is an open standard from Anthropic that lets LLM applications connect to external tools and data sources through a unified interface. An MCP server exposes resources (files, database rows, API endpoints) and tools (functions the model can call) to any compatible client. Claude Desktop, Cursor, VS Code Copilot, and dozens of agent frameworks all speak MCP now. Build one server, plug into all of them.

The protocol itself is JSON-RPC 2.0 over a transport layer. That transport is where hosting decisions start mattering.

Three transport modes, three hosting profiles

1. Stdio (local only)

The server runs as a subprocess of the client. The client spawns your binary, talks to it over stdin/stdout, kills it on exit. Zero network surface. Zero hosting needed.

This is how every Claude Desktop config you have ever seen works. command: "node", args: ["./my-server.js"], done. Great for personal tools, code that runs against your local filesystem, anything you do not want exposed to the internet.

Hosting cost: zero. You are the host.

2. HTTP with Server-Sent Events (SSE)

The original networked transport. Server runs as a long-lived HTTP service. Clients connect, hold an SSE stream open, send requests over POST. This is the mode most public MCP servers use today.

Hosting requirements: a process that stays running, a public URL with TLS, and a host that does not kill long-lived connections. That last one matters more than people realize. Serverless platforms with hard duration caps will close the SSE stream when the cap hits. On Vercel that is 5 minutes on Hobby and 800 seconds on Pro. For a session meant to stay open for hours, that is game over.

3. Streamable HTTP (the 2025 spec update)

Anthropic merged SSE and POST into one bidirectional endpoint. Stateless mode is possible. Each request is a self-contained exchange. This unlocks serverless and edge deployments because you no longer need a persistent connection.

Stateless streamable HTTP is the mode you want if your server does not need session memory. Stateful mode still requires a sticky backend.

Picking the right host

The decision tree:

Stateless streamable HTTP, low traffic: serverless or PaaS. Cheapest.
Stateful SSE, persistent connections: VPS or container platform.
High traffic, autoscaling: managed container service or Kubernetes.
Internal-only, behind VPN: any VPS with a private network.

Most teams overestimate which bucket they fall into. If your MCP server fronts a small API and gets a few hundred requests per day, you do not need Kubernetes. A 5 EUR VPS is fine.

Self-hosted on a VPS: the realistic baseline

This is what most production MCP servers actually run on. A small VPS, Node or Python process behind a reverse proxy, systemd keeping it alive. Total cost: under 10 EUR per month.

Provider	Plan	vCPU / RAM	Storage	Price
Contabo	Cloud VPS 4	4 / 8 GB	100 GB SSD	€4.40/mo excl. VAT, 24-month term
netcup	VPS 500 G12	2 / 4 GB	128 GB NVMe	€5.91/mo incl. VAT, 12-month term
Hetzner	CPX22	2 / 4 GB	80 GB NVMe	€19.49/mo excl. VAT, hourly billing
DigitalOcean	Basic Regular 1 GB	1 / 1 GB	25 GB SSD	$6/mo
Vultr	Regular Cloud Compute	1 / 1 GB	25 GB SSD	$5/mo
Linode	Shared Nanode	1 / 1 GB	25 GB SSD	$5/mo

The netcup VPS 500 G12 at €5.91 including VAT is the value pick now that Hetzner's budget CX line is gone. Two vCPUs and 4 GB RAM for the price of a coffee. It handles MCP servers with hundreds of concurrent SSE connections without breaking a sweat.

For pure value, Contabo Cloud VPS 4 at €4.40 excluding VAT gives you 4 vCPU and 8 GB RAM, but the I/O is slower and latency varies. Fine for a hobby MCP server. Not what you want for production.

If you are running multiple MCP servers and need elbow room, netcup's RS 1000 G12 with 4 dedicated AMD EPYC cores and 8 GB RAM at €12.79 including VAT is the sweet spot, on a 12-month minimum term. Hetzner's CCX13 with 2 dedicated vCPUs and 8 GB, the old default here, now costs €42.99 excluding VAT.

The setup, briefly

Provision the VPS. Install Node or Python. Clone your MCP server repo. Wrap the process in systemd (or PM2 if you prefer). Put Caddy or nginx in front for TLS. Open port 443. Done.

Anthropic publishes a TypeScript SDK and a Python SDK. Both have starter templates. Most teams have their first MCP server live in under an hour.

PaaS deployment: less work, slightly more money

If you do not want to think about systemd or TLS certs, Railway and Render handle the plumbing.

Railway charges per resource used. A small MCP server with 512 MB RAM and minimal CPU lands around $5 to $8 per month including bandwidth. You push from GitHub, Railway builds and deploys. SSE works out of the box because Railway runs your container long-lived.

Render's Web Service plans start at $7 per month for 512 MB RAM, $25 for 2 GB. Render also handles SSE and WebSockets correctly. Their free tier spins down after inactivity, which kills MCP servers, so do not use it for anything serious.

The tradeoff is honest: PaaS costs roughly 2x what a budget VPS costs for equivalent resources, and you trade that money for zero ops work. Worth it for small teams without an ops person.

For deeper PaaS analysis, see our PaaS hosting comparison.

Serverless: cheap and fast, with caveats

Streamable HTTP in stateless mode opens the door to truly serverless MCP servers. Cloudflare Workers, AWS Lambda, Vercel Functions can all host an MCP endpoint as long as each request is self-contained.

Cloudflare Workers is probably the best fit. Global edge, zero cold starts under typical load, $5 per month for 10 million requests on the paid tier. Their nodejs_compat flag handles the Anthropic SDK reasonably well.

Watch out for these limits:

Request timeout: Workers is 30 seconds CPU time, Lambda is 15 minutes max, Vercel is 5 minutes on Hobby and 800 seconds on Pro.
Response size: Workers caps at 100 MB streamed, Lambda at 6 MB synchronous.
Cold starts: relevant if your MCP server hits cold instances often. Workers wins here.

If your MCP server wraps a slow external API and individual tool calls might take 45 seconds, serverless is wrong. Use a VPS.

If your MCP server is a thin wrapper around a fast database query, serverless is perfect and you might never spend more than a few dollars per month.

The security part nobody likes talking about

An MCP server is a remote code execution surface for whoever talks to it. The LLM client calls tools on your server. Those tools execute code. If you expose that endpoint to the public internet without auth, you are running an open execution endpoint.

Here is what teams keep getting wrong:

1. No authentication on the MCP endpoint

The MCP spec supports OAuth 2.1 for HTTP transports. Use it. Anthropic added OAuth flows to the spec in 2025 specifically because too many public MCP servers shipped without auth.

If OAuth is too much for your use case, at minimum require a bearer token in the Authorization header and validate it on every request. Hardcoded API keys in env vars work fine for B2B MCP servers used by a single client team.

2. Tools that take filesystem paths

An MCP tool called read_file(path) that does no path validation is a path traversal exploit waiting to happen. The LLM will eventually try ../../../etc/passwd because the user asked it to debug something. Validate. Sandbox. Use chroot or container isolation for anything filesystem-related.

3. Database tools with no row-level filtering

If your MCP server exposes a query_users() tool, the LLM client speaks for whoever invoked it. Pass user identity through the protocol context and apply row-level security at the database. Otherwise tenant A can ask their AI for tenant B's data through your MCP server, and your AI will happily oblige.

4. Rate limiting

LLMs in agent loops can hammer an endpoint. A buggy agent we saw last quarter called the same MCP tool 4,000 times in two minutes before timing out. Without rate limiting that becomes your AWS bill. Caddy and Cloudflare both do this cheaply.

Real-world architecture: MCP server in front of a SaaS API

The most common production pattern in 2026 looks like this:

Your existing SaaS has a REST API.
You write an MCP server that wraps the REST API in tool definitions.
The MCP server runs on a small VPS or Railway service.
OAuth flow issues per-customer tokens.
Claude/Cursor/your-agent-of-choice connects to the MCP server using those tokens.

This unlocks AI integration without forcing your customers to integrate with twenty different agent frameworks. You build one MCP server. Everything else just works.

For a B2B SaaS doing 50,000 tool calls per day, this entire setup runs comfortably on a €5.91 netcup VPS 500 G12 with Caddy fronting the Node process. Total monthly bill: under 10 EUR including bandwidth.

Where MCP server hosting is going

Two trends to watch in 2026:

MCP marketplaces. Anthropic, Glama, and Smithery are building registries where third parties publish hosted MCP servers. You will not always host your own. You will sometimes use a hosted MCP server the way you use a third-party API today. Pricing models there are still shaking out, mostly per-call or per-seat.

MCP-native hosting platforms. A handful of providers are building dedicated MCP hosting products: deploy your server with one command, get OAuth and rate limiting included, pay per request. Expect this category to consolidate quickly. By 2027 we will probably have two or three dominant players the same way Vercel won Next.js hosting.

For now, a VPS plus a half-day of setup gets you a production MCP server cheaper than any managed alternative.

The 30-second recommendation

Building your first MCP server for testing? Stdio mode, local machine. No hosting.

Shipping an MCP server to a customer or to the public? A netcup VPS 500 G12 at €5.91 plus Caddy plus systemd. You will spend an hour setting up. The thing will run for years.

Already on a PaaS for your main app? Add the MCP server to the same project on Railway or Render. Your bill goes up by maybe $5 per month.

Want zero ops and very low traffic? Stateless streamable HTTP on Cloudflare Workers. Free tier handles a surprising amount.

The hosting decision matters less than the security one. Auth your endpoint, validate your tool inputs, rate-limit your server. Then ship.

Originally published at hostingsift.com

Self-Hosted LLM on a $5 VPS in 2026: What Actually Works

HostingSift — Wed, 12 Aug 2026 05:05:12 +0000

"Run your own ChatGPT for five bucks a month" sounds like cheap clickbait. And mostly it is. But the gap between clickbait and reality has narrowed a lot in 2026. Quantized 3B and 7B models have become genuinely useful. VPS providers now pack 8 GB of RAM into plans under $6. If you pick carefully, you can run a respectable local model on a budget server.

This article is about what actually works, what falls over, and which provider from our hosting comparison gives you the most compute per dollar for AI workloads.

The short version

You will not run GPT-4-class models on a $5 VPS. Stop expecting to.
You can run Llama 3.2-3B, Qwen 2.5-7B, or Mistral-7B in 4-bit quantization if you have at least 8 GB of RAM.
CPU inference is slow (5 to 15 tokens per second) but usable for personal automation, chatbots with low traffic, or embedding generation.
The providers that matter for this use case: Contabo and Netcup, both German-speaking and both useful for EU data residency. Hetzner has pulled its entire budget line from sale, so its entry point here is now €35.49 rather than €8.49.
Avoid US hyperscaler $5 plans (DO, Vultr, Linode) for LLM work. Same price, one quarter of the RAM.

Why self-host an LLM at all?

Three reasons keep coming up in our research:

Privacy. 44% of organizations cite data privacy as the top barrier to adopting hosted LLM APIs. Self-hosting means your prompts, documents, and customer data never leave your box. For law firms, clinics, and anyone building internal knowledge bases, this is non-negotiable.

Cost at volume. Hosted API costs add up fast once you run batch jobs, background summarization, or embedding pipelines. The rough break-even with a $5 VPS sits around two million tokens per day for small models. Below that, APIs are cheaper. Above that, self-hosting starts to win.

Learning and control. You get to pick the model, tune the system prompt at the weight level (via LoRA adapters), and run without rate limits. Worth it for developers.

What "self-hosted LLM" actually needs

Before we compare VPS plans, a quick hardware reality check. On CPU-only servers (which every budget VPS is), the bottleneck is RAM bandwidth, not CPU speed. Model weights must fit in RAM, and every token generation pass reads the entire weight file. So the two numbers that matter are:

RAM size. Determines which model you can load at all.
RAM bandwidth. Determines how many tokens per second you get.

Here is roughly what each tier can do in 4-bit quantization (GGUF format, llama.cpp inference):

**Update (21 September 2026).* netcup's ARM line, which this article recommended for tokens per euro, is sold out on netcup's site. It has been replaced below with netcup's x86 VPS 1000 G12, which you can order today. Hetzner's CX and CAX plans are now missing from its price list altogether. All prices were re-checked on 21 September 2026.*

**Update (12 August 2026) — corrections.* A data audit found two errors in the earlier version of this article, and we would rather say so plainly than quietly swap the numbers.*

**Hetzner's entire budget line is no longer sold.* The CX23/33/43/53 and CAX11/21/31/41 plans are marked "not available" on Hetzner's own site, in every location. Their listed prices are still accurate, which is exactly why our checks missed it — we were tracking price, not stock. The cheapest Hetzner plan you can actually buy with 8 GB of RAM is now the CPX32 at €35.49, roughly four times the €8.49 CX33 this article originally recommended. That single fact changes the shape of this comparison, so the Hetzner section below has been rewritten rather than repriced.*

**Our Contabo prices were wrong, and the catalogue was stale.* The Contabo plans quoted earlier — Cloud VPS 10 at €3.60 and Cloud VPS 20 at €5.60 — no longer exist. Contabo replaced that line with Cloud VPS 4 through 18 (the number is the vCPU count) and our scraper had been serving cached figures rather than reading the live site, understating some prices by up to 38%. Everything below is now read from Contabo's live pricing page.*

Netcup's VPS 1000 ARM G11 did move honestly, from €6.26 to €7.77. The full change history for all three is on our Hetzner, Netcup and Contabo price history pages.

RAM	Largest usable model	Realistic tokens/sec (CPU)	Good for
2 GB	Qwen 2.5-0.5B, Llama 3.2-1B	20-40 tok/s	Embeddings, simple classification
4 GB	Llama 3.2-3B, Phi-3.5 Mini	8-15 tok/s	Personal chatbots, summarization
8 GB	Qwen 2.5-7B, Mistral-7B, Llama 3.1-8B	4-8 tok/s	Production-adjacent use, RAG
16 GB	Mixtral 8x7B (barely), Qwen 2.5-14B	2-4 tok/s	More complex reasoning

Below 8 GB you are limited to small models. Above 8 GB you unlock the "actually useful" tier. This matters enormously when picking a VPS.

The $3 to $6 VPS plans that can run real LLMs

Pulled directly from our database, filtered to plans where the RAM is at least 8 GB (the practical floor for running a 7B model in 4-bit quantization) and that the provider will actually sell you today. The first price is the 24-month rate; the figure in brackets is what you pay month-to-month with no commitment.

Provider	Plan	Price / mo	RAM	vCPU	Storage	Bandwidth
Contabo	Cloud VPS 4	€4.40 (€5.50)	8 GB	4 vCPU	100 GB SSD	Unlimited
Contabo	Cloud VPS 6	€6.00 (€7.50)	12 GB	6 vCPU	200 GB SSD	Unlimited
netcup	VPS 1000 G12	€10.37 (12-month term)	8 GB	4 vCPU	256 GB NVMe	Unlimited
Contabo	Cloud VPS Plus 4	€10.80 (€13.50)	8 GB	4 vCPU (AMD EPYC)	150 GB NVMe	Unlimited
Hetzner	CPX32	€35.49	8 GB	4 vCPU	160 GB NVMe	20 TB

Contabo and Hetzner list prices before VAT. netcup's price includes 19% German VAT.

Compare that to the "famous" $5 cloud plans:

Provider	Plan	Price / mo	RAM	vCPU
DigitalOcean	Basic Regular	$4.00	512 MiB	1 vCPU
Vultr	CC Regular	$2.50	512 MB	1 vCPU
Linode	Shared Nanode	$5.00	1 GB	1 vCPU

That 8x RAM difference at the same price point is the whole reason European providers win this category. DO, Vultr and Linode are excellent for web apps and small services. They are not designed for the RAM-heavy workload an LLM needs.

Provider deep dive

Contabo: the price-per-GB winner

Contabo Cloud VPS 4 gives you 8 GB RAM, 4 vCPU and 100 GB SSD for €4.40 a month on a two-year term, or €5.50 with no commitment. Nothing else in this comparison matches that. The catch is real: Contabo is known for inconsistent CPU steal on noisy neighbours, and network latency can be variable. For LLM inference, which is RAM-bound rather than network-bound, that tradeoff is usually acceptable.

Go up one tier to Cloud VPS 6 at €6.00 (€7.50 monthly) for 12 GB RAM and 6 vCPU. This is the sweet spot for running Qwen 2.5-14B in 4-bit while still having headroom for a web server and a small vector database on the same machine.

One note on storage, since it changed with the new line: the standard Cloud VPS tiers ship SSD, not NVMe. If disk speed matters to you — loading an 8 GB model off disk on every restart, for instance — Cloud VPS Plus 4 at €10.80 keeps the same 8 GB of RAM but moves you to 150 GB of NVMe on AMD EPYC cores.

Hetzner: no longer competing at this price

Hetzner used to be the obvious quality pick here, and this article said so. That is no longer true, for a reason that has nothing to do with price: the whole cost-optimised line — CX23 through CX53 and CAX11 through CAX41 — is marked "not available" on Hetzner's site, in every location. The prices are still published, which is what fooled our tracker for a month, but you cannot buy the machines.

What remains purchasable with 8 GB of RAM starts at the CPX32, €35.49 a month. It is a genuinely good server — AMD EPYC cores, 160 GB NVMe, 20 TB of bandwidth, datacentres in Germany, Finland and Virginia, and a control panel that is minimal in the good way. It is simply in a different price bracket, four times the CX33 it replaces, and it is hard to justify for a hobby inference box when Contabo sells 8 GB for €4.40.

The loss worth mourning is the ARM line. The CAX21's Ampere Altra cores benchmarked roughly 15 to 25 percent faster than the x86 CX33 on llama.cpp thanks to higher sustained memory bandwidth, which made it the best tokens-per-euro option in this whole comparison. If Hetzner brings that line back, it goes straight back into this table — our Hetzner price history page tracks it nightly.

Netcup: the quiet competitor

Less known outside the German-speaking market. Its ARM line, the VPS 1000 ARM G11 with 6 vCPU and 8 GB at €7.77, was the pick here until netcup marked the whole ARM range sold out. The x86 VPS 1000 G12 is the plan you can buy today: 4 vCPU, 8 GB of DDR5 and 256 GB of NVMe for €10.37 a month including VAT on a 12-month term. That is still the largest disk in this comparison. Useful if you want to store multiple models and switch between them without re-downloading 4 to 8 GB each time.

What you will actually run on 8 GB

Here is the honest menu for an 8 GB VPS with Ollama or llama.cpp:

Qwen 2.5-7B-Instruct (Q4_K_M). Best general-purpose model in this size. Strong reasoning, multi-language, clean code.
Llama 3.1-8B-Instruct (Q4_K_M). Ubiquitous, well-supported, safe default. Slightly weaker than Qwen on code.
Mistral-7B-Instruct-v0.3 (Q5_K_M). Older but predictable. Good for summarization.
Phi-3.5-Mini (Q6_K). Smaller (3.8B), fits in 4 GB of RAM, quick for chat.
nomic-embed-text or bge-small-en. Embedding models for RAG pipelines. Run these alongside the main model.

What you will not run well: anything 14B+, models with vision capabilities (qwen-vl, llava), or anything demanding low-latency streaming to many users.

Practical setup in 15 minutes

Rough sketch so you know what you are signing up for. This assumes Ubuntu 22.04 or 24.04 on a 8 GB VPS.

# 1. Install Ollama (handles download, quantization, serving)
curl -fsSL https://ollama.com/install.sh | sh

# 2. Pull a model
ollama pull qwen2.5:7b-instruct-q4_K_M

# 3. Test
ollama run qwen2.5:7b-instruct-q4_K_M "Summarize the French Revolution in two paragraphs."

# 4. Expose the API (careful with firewall rules)
# Ollama serves on localhost:11434 by default. Reverse-proxy with Caddy or Nginx.

Add Open WebUI if you want a ChatGPT-like browser interface. Add llama-swap if you want to load different models on demand without restarting.

When NOT to self-host

A $5 VPS gives you about 5 to 8 tokens per second on a 7B model. That is fine for one user typing in a chat. It is not fine for:

Real-time voice assistants. Latency will be embarrassing.
Multi-user chat services. Four concurrent users will queue and feel broken.
Anything that needs tool use, function calling at scale, or long-context (>8K tokens).
Production RAG over millions of documents with tight latency SLAs.

For those workloads, you want a GPU instance. That immediately pushes you above $100/month with Vast.ai, RunPod, or a dedicated server with a consumer GPU. At that point, OpenAI API or Anthropic API is often cheaper up to surprisingly high volumes.

Quick comparison: which $5 to $7 VPS wins?

Use case	Best pick	Why
Lowest price with 8 GB RAM	Contabo Cloud VPS 4	€4.40 for 8 GB is unmatched
Best tokens per second per euro	No clear pick today	Both ARM lines that led here, Hetzner CAX and netcup ARM G11, are sold out
Largest model storage	netcup VPS 1000 G12	256 GB NVMe stores a dozen models easily
Fast disk for model loading	Contabo Cloud VPS Plus 4	150 GB NVMe on EPYC; standard Cloud VPS is SSD
Running LLM + web app on one box	Contabo Cloud VPS 6	12 GB RAM leaves room for Postgres and nginx
Reliability regardless of price	Hetzner CPX32	The cheapest 8 GB Hetzner you can still buy, at €35.49

You can also compare them side by side on Contabo vs Hetzner or review the full cloud VPS category.

What changes this year

Two developments worth tracking in 2026:

Smaller models keep getting smarter. Phi-3.5 Mini already outperforms last year's 13B models on some benchmarks. Expect 2B and 3B models to be genuinely production-useful by Q4 2026. That makes the 2 GB RAM tier (under $2) a legitimate option.

ARM inference is closing the gap. Apple showed what M-series can do. Ampere Altra and AWS Graviton are bringing similar memory bandwidth advantages to $5 VPS plans. If you have not tried ARM yet, this is the year.

The verdict

If you want to learn, build a personal assistant, run background summarization, or stand up a private chatbot for a small team, a €5 to €8 VPS with 8 GB of RAM is genuinely enough in 2026. Pick Contabo for raw price, netcup for the biggest disk. Hetzner is still the reliability benchmark, but until its cost-optimised line comes back, entry is €35.49 rather than €8.49. Avoid the US hyperscaler budget tiers; they are optimised for a different use case.

If you want to serve real users at real volume, stop pretending a shared VPS is the answer. Use an API, or skip straight to a GPU host.

The Raw Power of Svelte 5 Runes: 70 Components, 25 KB, Full Reactivity

HostingSift — Wed, 25 Feb 2026 13:14:30 +0000

Svelte 5 Runes in Production: What We Learned Building 70+ Components

When Svelte 5 shipped runes, the community split in two. One side said "you're just copying React." The other saw the future of reactivity. We just started writing code. 70+ components later, powering HostingSift (a hosting comparison platform), here's what we actually know.

What runes are and why you should care

Runes are compiler instructions. They look like functions ($state(), $derived(), $effect()), but they're not. Svelte transforms them at build time, not at runtime. That's the key difference from React hooks, Vue composables, and everything else out there.

In Svelte 4, reactivity was implicit. Write let count = 0 and the compiler decides when to update the DOM. It worked, but it had traps. $: blocks got confusing with complex logic, and the line between "reactive" and "just a variable" was blurry.

Runes fix that with explicit signals:

<script lang="ts">
  let hostings = $state<Hosting[]>([])
  let loading = $state(true)
  let error = $state<string | null>(null)
  let currentSort = $state('rating')

  const totalPages = $derived(Math.ceil(total / limit))

  $effect(() => {
    if (currentQueryString !== undefined) {
      fetchHostings()
    }
  })
</script>

You read it and know exactly what's reactive. No magic. No guessing.

The reactivity model: what actually happens under the hood

Here's the thing most articles skip. Svelte 5's reactivity is signal-based, but the compiler does the dependency tracking for you. You never call createSignal() or wrap things in ref(). You write normal JavaScript and the compiler figures out the reactive graph.

When you write:

let loading = $state(true)

The compiler turns it into something like:

let loading = $.source(true)

Every read of loading in the template or in a $derived/$effect block registers a dependency. Every write triggers updates to anything that depends on it. No manual dependency arrays. No stale closure bugs.

This is fundamentally different from React's model. In React, useEffect re-runs based on a dependency array you maintain. Forget a dependency, get a stale value. Add too many, get infinite loops. Svelte tracks dependencies automatically because it controls the compiler. The reactive graph is built at compile time, not runtime.

Compared to Vue's ref() / reactive(), you also skip the .value ceremony. In Vue you write count.value++. In Svelte you write count++. The compiler knows it's reactive and generates the right code.

How we built a reactive filter system with runes

This is where runes really clicked for us. Our hosting comparison page has multiple filter dimensions: hosting type, technology stack, price range, search, sort order, pagination. Each filter lives in its own nanostore atom, and they all feed into a computed API query string.

Here's the store layer (plain nanostores, framework-agnostic):

// stores/filters.ts
import { atom, computed } from 'nanostores'

export const $type = atom<string | null>(null)
export const $tech = atom<string[]>([])
export const $minPrice = atom<number>(0)
export const $maxPrice = atom<number>(1000)
export const $sort = atom<string>('price-asc')
export const $page = atom<number>(1)
export const $search = atom<string>('')

// This recomputes whenever ANY filter changes
export const $apiQueryString = computed(
  [$type, $tech, $minPrice, $maxPrice, $sort, $page, $search],
  (type, tech, minPrice, maxPrice, sort, page, search) => {
    const params = new URLSearchParams()
    if (type) params.set('type', type)
    if (tech.length) params.set('tech', tech.join(','))
    // ...
    return params.toString()
  }
)

Seven independent atoms feeding into one computed query string. When you change any filter, $apiQueryString recomputes and the list refetches. That's the reactive graph in action.

Now here's the interesting part: bridging this into Svelte 5 components.

The bridge pattern we use everywhere

Nanostores don't know about runes. So we bridge them with a pattern that shows up in almost every component:

<script lang="ts">
  import { $type as typeStore, setType } from '../../stores/filters'

  let activeType = $state<string | null>(typeStore.get())

  $effect(() => {
    return typeStore.subscribe(val => { activeType = val })
  })
</script>

Three lines: initial value from the store, subscribe in an effect, cleanup returned automatically. Every filter component does this. TypeTabs, TechFilter, PriceRangeSlider, ActiveFilters all follow the same pattern.

For components that track multiple stores, we batch the subscriptions:

$effect(() => {
  const unsubs = [
    typeStore.subscribe(val => { currentType = val }),
    techStore.subscribe(val => { currentTech = val }),
    minPriceStore.subscribe(val => { currentMinPrice = val }),
    maxPriceStore.subscribe(val => { currentMaxPrice = val }),
    priceMaxStore.subscribe(val => { ceiling = val }),
    priceFloorStore.subscribe(val => { floor = val }),
  ]
  return () => unsubs.forEach(unsub => unsub())
})

One effect, six subscriptions, one cleanup function. The effect runs once on mount, subscribes to everything, and cleans up all listeners when the component is destroyed. In React you'd need useEffect with a dependency array (probably wrong on the first try) or multiple useEffect calls. Here it's flat and obvious.

$derived for computed filter state

The real power shows when you start deriving values. Our ActiveFilters component needs to know if any filter is active:

const hasFilters = $derived(
  currentType !== null ||
  currentTech.length > 0 ||
  currentMinPrice > floor ||
  currentMaxPrice < ceiling
)

No useMemo. No cache key. Just an expression that re-evaluates when any of its dependencies change. Svelte tracks which $state variables you read inside $derived and only recalculates when those specific values change.

The TechFilter component uses $derived for show/hide logic:

const visibleOptions = $derived(
  showAll ? techOptions : techOptions.slice(0, VISIBLE_COUNT)
)
const hiddenCount = $derived(
  Math.max(0, techOptions.length - VISIBLE_COUNT)
)

When showAll flips or techOptions changes (after the API responds), both derived values update and the template re-renders. You don't think about it. It just works.

The price slider: reactive all the way down

Our dual-range price slider is the most reactive component we have. It juggles local drag state, store values, computed percentages, and dynamically generated pip labels:

let localMin = $state(minPriceStore.get())
let localMax = $state(maxPriceStore.get())
let ceiling = $state(priceMaxStore.get())
let isDragging = $state(false)

// Sync from store, but not while dragging
$effect(() => {
  const unsubMin = minPriceStore.subscribe(val => {
    if (!isDragging) localMin = val
  })
  const unsubMax = maxPriceStore.subscribe(val => {
    if (!isDragging) localMax = val
  })
  // ...
  return () => { unsubMin(); unsubMax(); /* ... */ }
})

// These recompute on every drag frame
const range = $derived(ceiling - floor)
const minPercent = $derived(range > 0 ? ((localMin - floor) / range) * 100 : 0)
const maxPercent = $derived(range > 0 ? ((localMax - floor) / range) * 100 : 100)

As the user drags, localMin/localMax update, which triggers minPercent/maxPercent to recompute, which moves the slider fill in the template. When they release, we commit to the store, which triggers the API fetch. The isDragging guard prevents the store subscription from fighting with the local drag state.

In React you'd model this with useState + useRef + useCallback + useEffect with carefully managed dependency arrays. Here it's just assignments and derived values. The compiler handles the rest.

The pip labels are a $derived.by() because the logic needs intermediate variables:

const pips = $derived.by(() => {
  if (range <= 0) return [`$${floor}`]
  const rough = range / 5
  const mag = Math.pow(10, Math.floor(Math.log10(rough || 1)))
  const norm = rough / mag
  const step = norm <= 1 ? mag : norm <= 2 ? 2 * mag : 5 * mag
  const labels: string[] = [`$${floor}`]
  for (let v = Math.ceil(floor / step) * step; v < ceiling; v += step) {
    labels.push(`$${v}`)
  }
  return labels
})

$derived() is for single expressions. $derived.by() is for when you need if, for, or temporary variables. Both are reactive the same way.

$effect: the cleanup story

The killer feature of $effect isn't the effect itself. It's the cleanup. You return a function and Svelte calls it when dependencies change or the component unmounts. No onDestroy import, no separate cleanup lifecycle.

Click outside handler with automatic cleanup:

$effect(() => {
  if (searchOpen) {
    document.addEventListener('click', handleClickOutside)
    return () => document.removeEventListener('click', handleClickOutside)
  }
})

The listener only exists while the dropdown is open. Close it, listener gone. Unmount the component, listener gone. You can't forget.

Body scroll lock for a mobile bottom sheet:

let isOpen = $state(false)

function open() {
  isOpen = true
  document.body.style.overflow = 'hidden'
}

function close() {
  isOpen = false
  document.body.style.overflow = ''
}

No effect needed here because the state change is synchronous and user-driven. That's another thing runes teach you: not everything needs to be reactive. Sometimes a plain function is better.

The simplicity argument: less code, fewer bugs

Let's be blunt. Every framework claims to be simple. But simplicity isn't about marketing copy. It's about how much code you write for the same result, and how many places that code can go wrong.

Here's a toggle button. React:

const [isOpen, setIsOpen] = useState(false)

Vue:

const isOpen = ref(false)

Svelte:

let isOpen = $state(false)

All three are one-liners. Fair enough. Now let's look at something real: a component that reads from an external store, derives a computed value, and cleans up on unmount.

React version of our TypeTabs filter:

function TypeTabs() {
  const [activeType, setActiveType] = useState(typeStore.get())

  useEffect(() => {
    const unsub = typeStore.subscribe(val => setActiveType(val))
    return unsub
  }, [])

  const handleClick = useCallback((value) => {
    setType(value)
  }, [])

  return (
    <div className="flex flex-wrap gap-2">
      {TYPES.map(t => (
        <button
          key={t.value}
          className={`chip ${activeType === t.value ? 'active' : ''}`}
          onClick={() => handleClick(t.value)}
        >
          {t.label}
        </button>
      ))}
    </div>
  )
}

Svelte version. The actual code we ship:

<script lang="ts">
  import { $type as typeStore, setType } from '../../stores/filters'

  let activeType = $state<string | null>(typeStore.get())

  $effect(() => {
    return typeStore.subscribe(val => { activeType = val })
  })
</script>

<div class="flex flex-wrap gap-2">
  {#each TYPES as t}
    <button
      class="chip {activeType === t.value ? 'active' : ''}"
      onclick={() => setType(t.value)}
    >
      {t.label}
    </button>
  {/each}
</div>

Count the concepts. React: useState, useEffect, useCallback, dependency array, JSX return statement, className instead of class, key prop. Svelte: $state, $effect, template. That's it.

The React version has more ways to break. Forget the dependency array, you get stale state. Skip useCallback, you get unnecessary re-renders (or your linter screams at you). The Svelte version has one moving part: the store subscription with automatic cleanup.

Now look at our ActiveFilters component. It subscribes to 6 stores and derives a boolean:

let currentType = $state(typeStore.get())
let currentTech = $state(techStore.get())
let currentMinPrice = $state(minPriceStore.get())
let currentMaxPrice = $state(maxPriceStore.get())
let ceiling = $state(priceMaxStore.get())
let floor = $state(priceFloorStore.get())

$effect(() => {
  const unsubs = [
    typeStore.subscribe(val => { currentType = val }),
    techStore.subscribe(val => { currentTech = val }),
    minPriceStore.subscribe(val => { currentMinPrice = val }),
    maxPriceStore.subscribe(val => { currentMaxPrice = val }),
    priceMaxStore.subscribe(val => { ceiling = val }),
    priceFloorStore.subscribe(val => { floor = val }),
  ]
  return () => unsubs.forEach(unsub => unsub())
})

const hasFilters = $derived(
  currentType !== null ||
  currentTech.length > 0 ||
  currentMinPrice > floor ||
  currentMaxPrice < ceiling
)

In React, this would be six useState calls, a useEffect with an empty dependency array, and a useMemo with six dependencies (that you'd probably get wrong on the first try). Or you'd pull in Zustand or Jotai and add another abstraction layer.

In Svelte, it's assignments and one effect. $derived doesn't need you to list dependencies. The compiler reads the expression and tracks them automatically.

This scales. Our most complex component (HostingList) has 12 $state declarations, 4 $derived values, 5 $effect blocks, and handles search, sort, filters, pagination, and compare selection. It's 286 lines including the template. The equivalent React component would easily be 400+, and most of that extra code would be dependency arrays, memoization, and state setter functions.

The point isn't that React is bad. It's that Svelte's compiler does work that React pushes onto the developer. Less manual bookkeeping means fewer places to mess up.

$props: TypeScript-first component contracts

interface Props {
  items: CompareItem[]
  max?: number
  onRemove: (id: string) => void
  onClear: () => void
  onCompare: () => void
}

let { items, max = 4, onRemove, onClear, onCompare }: Props = $props()

Instead of export let items and hoping the parent passes the right type. TypeScript catches mistakes at compile time. Default values work with standard destructuring. Callbacks are just props, same as React.

Bundle size: the actual numbers

Svelte 5 compiles runes to vanilla JS at build time. There's no 40+ KB runtime (React) or 30+ KB runtime (Vue) shipped to the browser. Svelte's runtime is under 5 KB gzipped and tree-shakes aggressively.

In our case: 70+ Svelte components including a quiz wizard, dual-range price slider, filter system, compare bar, review form, and a full admin panel. Client JS stays under 25 KB per page (gzipped, including routing). React's runtime alone is bigger than that.

Runes add zero overhead. $state(0) compiles to:

let rating = $.source(0)

$derived(items.length >= 2) becomes:

let canCompare = $.derived(() => $.get(items).length >= 2)

The compiler knows exactly which values are reactive and generates only the code it needs. No virtual DOM diffing. No runtime dependency tracking. Just surgical DOM updates.

What surprised us

Granular updates without effort. When hostings = newArray runs, Svelte doesn't re-render the whole list. It diffs the keyed {#each} block and only touches changed DOM nodes. We never had to think about React.memo or shouldComponentUpdate.

Conditional effects actually work. $effect + if + return cleanup gives you fine-grained control in 5 lines. The click-outside handler above would be a custom hook in React (15+ lines, reusable but noisy).

TypeScript just works. $state<Hosting[]>([]) does what you expect. No wrapper types, no utility generics, no Ref<T> vs T.

Derived chains are fast. floor changes, range recomputes, minPercent recomputes, pips recomputes, DOM updates. Four levels of derived state and it's instant because each step only runs if its inputs changed.

What bites

The nanostores bridge. Four lines per store isn't terrible, but it's ceremony. We'll probably write a useNanostore() utility at some point. For now the pattern is consistent and bug-free.

$effect grabs everything it reads. If you read currentQueryString inside an effect, the effect re-runs when it changes. This is correct behavior, but you need to be careful not to trigger infinite loops (effect writes to state that the effect reads).

Migrating from Svelte 4. Not trivial. $: blocks need to be split into $derived and $effect. export let becomes $props(). The good news: npx sv migrate svelte-5 handles 90% of cases.

Quick reference

Rune	Use case	Example
`$state()`	Mutable value	`let loading = $state(true)`
`$derived()`	Computed from state	`const total = $derived(items.length)`
`$derived.by()`	Complex computed with if/for	`$derived.by(() => { ... })`
`$effect()`	Side effects, subscriptions	Fetch, event listeners, store sync
`$props()`	Component inputs	`let { name } = $props()`
`$bindable()`	Two-way binding prop	`let { value = $bindable() } = $props()`

Bottom line

Runes make reactivity explicit. You know what's state, what's computed, what's a side effect. The compiler generates minimal code. TypeScript works without hacks. The reactive graph is built once at compile time and runs with near-zero overhead.

We run 70+ components in production at HostingSift with Astro SSR, nanostores for cross-island state, and Svelte 5 runes for local reactivity. A full filter system with type tabs, technology chips, a dual-range price slider, active filter pills, search with autocomplete, and sort dropdown. All reactive, all coordinated through a single computed query string, all under 25 KB shipped to the browser.

If you're starting a new project and the React/Vue/Svelte decision is eating your time, just try runes. They're different enough to deserve a real look.

Why we chose Astro over SvelteKit for our hosting comparison platform

HostingSift — Mon, 23 Feb 2026 21:00:31 +0000

Why we chose Astro over SvelteKit for our hosting comparison platform

We're building HostingSift, a platform for comparing hosting providers side by side. Pricing tables, feature breakdowns, filters, user reviews. When we started, we had one decision that would shape everything else: SvelteKit or Astro?

We went with Astro. Here's why.

Some context first

HostingSift is a content-heavy site. We have 23+ hosting provider profiles, each with multiple plans, pricing tiers, feature specs, and user reviews. On top of that there are comparison pages, category listings, a recommendation quiz, and a blog.

The interactive parts are specific and well-contained: filtering plans by billing period, toggling comparison tables, authentication flows, review forms. Most of what users actually see is static content that doesn't need JavaScript to render.

This ratio matters. It shaped everything that followed.

SvelteKit was the obvious choice

We love Svelte. The reactivity model in Svelte 5 with runes is elegant. The developer experience is fantastic. SvelteKit is a mature, full-featured framework with file-based routing, SSR, API endpoints, form actions.

So why not just use it?

Because SvelteKit is an application framework. It assumes your pages are interactive by default. Every route ships a JavaScript bundle to hydrate the page client-side, even if the page is mostly static HTML.

You can work around this. You can set ssr: true and use +page.server.ts to keep data fetching on the server. You can prerender specific routes. But you're swimming against the current. The defaults push you toward shipping more JavaScript than a content site needs.

What Astro gets right for content sites

Astro starts from the opposite end. Zero client JavaScript by default. Every page renders as static HTML until you explicitly opt in to interactivity.

This is not a subtle difference. It changes how you think about building pages.

Islands, not full-page hydration

With Astro, we compose pages from .astro components (static HTML, zero JS) and Svelte components (interactive, with JS). The Svelte components are islands. They hydrate independently. The rest of the page is just HTML that the browser renders immediately.

Our hosting profile page is a good example. The page layout, provider description, specs table, pros and cons list, SEO metadata... all static Astro components. Zero JavaScript shipped. Then we drop in a PlanCard component with client:load for the interactive pricing table where users toggle billing periods. A ReviewForm for authenticated review submission. A HeaderAuth for login state.

---
import Layout from '../../layouts/Layout.astro'
import PlanCard from '../../components/PlanCard.svelte'
import ReviewSection from '../../components/ReviewSection.svelte'
import SpecsTable from '../../components/SpecsTable.astro'

const { hosting, plans } = await fetchHostingData(slug)
---

<Layout title={hosting.name}>
  <article>
    <h1>{hosting.name}</h1>
    <p>{hosting.description}</p>

    <!-- Static HTML, no JS overhead -->
    <SpecsTable specs={hosting.specs} />

    <!-- Interactive islands, hydrate independently -->
    <PlanCard client:load plans={plans} />
    <ReviewSection client:load hostingId={hosting.id} />
  </article>
</Layout>

Each island hydrates on its own. If one fails, the rest of the page still works fine. In SvelteKit, the entire page is a single hydration unit.

Prerendering is the default, not an opt-in

In Astro's hybrid mode, pages are prerendered at build time unless you explicitly say otherwise. Our homepage, category pages, legal pages, blog posts... all static HTML files. Fast, cacheable, no server compute on each request.

For pages that need fresh data (hosting profiles with live pricing, filtered listings), we mark them as server-rendered. It's explicit and intentional.

SvelteKit takes the opposite approach. Everything is server-rendered by default. You opt in to prerendering per route. The mental model is reversed. For a site where the majority of pages can safely be static, Astro's default aligns better with reality.

We still write Svelte

This is what made the decision easy. Astro is not a replacement for Svelte. It's a composition layer around it.

All our interactive components are pure Svelte 5 with runes, stores, reactive state. We didn't lose anything from the Svelte ecosystem. We just moved the routing and page composition up to Astro, where it can make smarter decisions about what ships to the browser.

The pattern feels natural once you get used to it. Page structure lives in .astro files (templating with zero overhead). Interactive behavior lives in .svelte files (full reactivity where it's actually needed).

The tradeoffs we accepted

Astro is not a free lunch. Here's what we gave up.

No form actions

SvelteKit's form actions with progressive enhancement are genuinely nice. In Astro, we handle forms through our Hono API with client-side fetch calls. It works, but there's more boilerplate involved. We write onSubmit handlers and manage loading states manually where SvelteKit would handle the plumbing for us.

Two component models

Anyone working on the codebase needs to understand both .astro and .svelte files. When does something belong in Astro vs Svelte? The rule is straightforward (static content = Astro, interactive behavior = Svelte), but it's still a decision you make dozens of times a day.

View Transitions have rough edges

Astro's View Transitions look great but come with real gotchas. Inline scripts re-execute on each navigation. We spent more time than expected getting Google Analytics and vanilla-cookieconsent to behave correctly, adding guard flags to prevent double initialization. SvelteKit's client-side routing handles this more gracefully out of the box.

Separate API server

SvelteKit has +server.ts for API routes, tightly integrated with the framework. We chose to run a standalone Hono server for our API. This was intentional (the API will eventually serve a mobile app too), but it means two processes to manage, separate deployments, and CORS configuration that SvelteKit wouldn't need.

Where this paid off

The results justified the decision.

Our homepage ships about 40KB of JavaScript total. The interactive bits (provider grid, newsletter form) are small isolated bundles. In a SvelteKit setup, the framework's client-side router adds baseline overhead before any of our code even loads.

Server-side OG image generation fits naturally into Astro's endpoint model. We generate dynamic Open Graph images for every hosting profile, comparison page, and blog post using Satori and Sharp. It's just a standard API route that returns a PNG buffer. No special configuration needed.

Build times stay fast. Prerendering 50+ static pages, generating sitemaps, and compiling the Svelte islands takes under 30 seconds. Adding a new provider doesn't slow anything down because the build is mostly parallel.

The deployment question

This one doesn't get discussed enough.

SvelteKit works everywhere in theory. In practice, the smoothest path is deploying to Vercel. Rich Harris works there, adapter-auto detects Vercel out of the box, and the integration is polished. You can absolutely use adapter-node and self-host, but you'll be configuring things that Vercel handles for you automatically.

We wanted to self-host. Our stack runs on a single Hetzner ARM64 VPS: the Astro site, the Hono API, PostgreSQL, all behind nginx and Cloudflare. The whole thing costs about €5 a month.

With Astro, deploying to a VPS was straightforward. Install @astrojs/node, build, run with PM2. That's it. No adapter quirks, no platform-specific edge cases. The output is a standard Node.js server.

The cost angle is worth mentioning too. Platforms like Vercel and Netlify use usage-based pricing. The Pro plans start at $20-25 per month, but the real cost depends on traffic, serverless function execution time, and bandwidth. Overages are billed automatically. There are well-documented cases of bills spiking unexpectedly after traffic surges or bot crawls. For a content site that serves a lot of static pages, this pricing model works against you.

A fixed-cost VPS eliminates that variable entirely. Traffic can double or triple and the bill stays the same. If we outgrow the current server, the next tier up is still a fraction of what a managed platform would cost at equivalent traffic. We're not locked into any vendor's pricing model, and migrating to a bigger box is a straightforward process.

To be fair, managed platforms give you CI/CD, preview deployments, edge functions, and zero-config scaling. Those are real features with real value, especially for teams that don't want to manage infrastructure. The tradeoff is control and cost predictability versus convenience.

For us, a €5 VPS with full control was the obvious pick.

After several months in production

23 hosting providers, hundreds of plans, comparison pages, a quiz, a blog, user auth, admin panel. All running on that single Hetzner box.

The architecture has held up. New provider profiles are just data. New interactive features are new Svelte islands dropped into existing pages. New static pages are .astro files with no client-side cost.

Would SvelteKit have worked? Of course. For a more app-like product with dashboards, real-time collaboration, heavy client state, we'd pick SvelteKit without thinking twice.

But for a content-first site where interactivity is the exception rather than the rule, Astro with Svelte islands turned out to be the right call. Not because SvelteKit couldn't do it. Because Astro's defaults already pointed in the direction we wanted to go.

There's real value in not having to fight your framework.

I Built a Hosting Comparison Platform with Astro, Svelte 5 & Hono

HostingSift — Sat, 21 Feb 2026 08:59:10 +0000

I got tired of hosting comparison websites. You know the ones. "Top 10 Best Hosting 2024" articles that haven't been updated since 2022, prices that are completely wrong, and rankings that suspiciously always put the same provider first no matter what.

So I decided to build my own. Not a blog post with affiliate links, but an actual tool where you can filter by hosting type, compare plans side by side, and see prices that are actually current. After about six months of work, HostingSift is live and I figured I'd share what went into it.

Why This Stack

Astro in hybrid SSR mode was the obvious pick. Most pages (hosting profiles, categories, homepage) get prerendered at build time, which means they're fast out of the box. A few routes like the comparison tool need server rendering, and Astro handles that switch per-page which is really convenient.

For interactive bits I went with Svelte 5. I was on React before and honestly the new runes API ($state, $derived, $effect) won me over pretty quickly. No dependency arrays, no stale closures, components feel lighter. It took maybe a week to get comfortable with the mental model shift and after that I didn't look back.

The backend is Hono on Node.js. Think Express but with actual TypeScript support and better performance. It handles auth, the admin panel API, affiliate click tracking, all that stuff. Database is PostgreSQL with Drizzle ORM which has been solid for both queries and migrations.

Everything lives in a monorepo: apps/web, apps/api, packages/db, packages/email. pnpm workspaces glue it together.

Keeping Prices Up to Date

The whole point of the site is showing accurate pricing, so I built an automated pipeline that pulls plan data from each provider on a weekly schedule. Every plan, every billing period, every feature toggle. It compares incoming data against what's already in the database and upserts the differences. Each run also creates a snapshot, so if a provider quietly bumps their renewal price by $2/month, that gets recorded. Over time this builds a price history for every single plan.

Getting the data right for each provider was the biggest time sink. Every provider structures their pricing page differently. Some have clean layouts, others hide plans behind tabs and dropdowns, and a few change their page structure often enough that things break. You end up writing very provider-specific logic and accepting that maintenance is part of the deal.

Things I'd Do Differently

I'd spend more time on data validation early on. I almost "fixed" what looked like a pricing bug for one provider before checking their actual website. Turns out they give their biggest promotional discount to mid-tier plans, not the cheapest ones. Now I always verify against the source before touching anything in the database.

Svelte 5 + Astro is a great combo but the ecosystem is still catching up. Some things that are one-line solutions in React/Next don't have equivalents yet. The tradeoff is worth it though, the output is noticeably lighter and the developer experience is genuinely good.

Try It

HostingSift is live if you want to check it out. You can filter by hosting type, compare providers, see current prices. Still adding more providers and features so if something looks off or you have ideas, I'd love to hear about it in the comments.