All systems operational 12 elite locations · Europe & Asia Pay with crypto · 0 KYC
Home / Guides / VPS vs Dedicated: When to Switch
Guide

VPS vs Dedicated — When to Switch (Same Crypto Checkout)

VPSbit VPS vs dedicated - same crypto checkout

CPU steal, swap, NVMe queues, IPMI: four numbers that decide VPS vs dedicated. The VPS ladder tops out at $24; Forge metal sits at $39.20/mo annual-eff.

Short answer

CPU steal, swap, NVMe queues, IPMI: four numbers that decide VPS vs dedicated. The VPS ladder tops out at $24; Forge metal sits at $39.20/mo annual-eff.

AMD Ryzen 9 9950X → 2× AMD EPYC 9554PECC DDR5NVMe RAID 0/1/5/10IPMI on all1–25 Gbps unmetered19 coins + XMR

Plan ledger

PlanCPURAMNVMeRAIDPortIPMIPrice
Forge16c / 32t32 GB DDR52 x 1 TB NVMe RAID 0/10/11 GbpsIPMI + DDoS$49 list · $39.20/mo annual
Summit32c / 64t64 GB DDR5 ECC2 x 2 TB NVMe RAID 0/10/110 GbpsIPMI + DDoS$89 list · $71.20/mo annual
Monolith128c / 256t dual128 GB DDR5 ECC4 x 2 TB NVMe Gen4 RAID 0/1/5/100/1/5/1025 GbpsL3/L7 scrubber$149 list · $119.20/mo annual

Full ledger: all dedicated SKUs.

One invoice, two classes: the decision is hardware, not rails

Because both classes settle through the identical nineteen-coin checkout, choosing between them is not a payment question, an admin-skill question or an ideology question — it is a quartet of hardware readings. A VPS is a reserved slice of a shared chassis; a dedicated server is the entire machine, racked and surrendered to you with its console. Everything beyond that is packaging and brochure adjectives.

The slice hands you a plan table instead of a ration: full root on KVM, nested virtualization, unrestricted Docker, custom ISOs, raw sockets — the hypervisor boundary is the only fence (the KVM project documents the model). The machine hands you the socket, the disk lanes and the baseboard: no strangers on the memory bus, no contested storage queue, and a lights-out console that answers even when the operating system refuses to.

Price-wise the classes stand one step apart: the VPS staircase ends at Titan — 8 vCPU, 32 GB DDR5 ECC, 320 GB NVMe, 10 Gbps — at $24 list, $19.20 annual-eff; metal opens at Forge — 16c/32t Ryzen 9 9950X, 32 GB, 2×1 TB NVMe, 1 Gbps, IPMI — at $49 list, $39.20 annual-eff. The VPS ledger and the dedicated ledger publish both columns in full.

Notice what does not differ: checkout flow, provisioning pipeline, the DDoS scrubbing in front, the flat-rate ports, the twelve-site geography, the abuse regime of whichever facility hosts the racks. The catalog deliberately keeps everything except hardware identical, which is a courtesy to your future self — crossing between classes reuses every operational habit you already built, from key-only login to backup rotation.

The recurring error is buying metal to obtain capabilities the hypervisor already grants — your own boot images, container runtimes, kernel parameters — and funding idle exclusivity for the privilege. Metal buys four things slices cannot ship: whole-socket compute, uncontested storage lanes, ECC-first architecture with a console, and array choice. Audit those four before touching either order button; the sections that follow are the measurement protocol, in the order the failures usually arrive.

VPS from $4.80* — Core on the annual term (list $6/mo), one invoice for 12 months, no auto-charges. Dedicated with IPMI from $39.20/mo. Crypto invoice, no KYC.

Launch now

CPU steal: the number that ends the VPS era

Steal time is the nearest thing virtualization has to a polygraph: it is the fraction of your paid processor seconds the scheduler diverted elsewhere because you never owned the socket. Under a couple of percent it is weather. Persistently above a few percent, a stranger is drinking your clock — and no resize inside the same oversubscribed host corrects a crowded tenancy.

The kernel books the accounting in /proc/stat, with the steal column documented alongside user and system time in the proc manual page (proc(5) manual). Watch it the way operators do: vmstat 1 in a pane, eyes on the st column, across a full week of business hours rather than one charmed Tuesday. A spike during a neighbor's backup is an anecdote; a rising weekly baseline is a verdict.

Modern kernels also expose pressure stall information — the share of time tasks spent waiting for the processor — through /proc/pressure (documented in the kernel admin guides — PSI documentation), and some readings matter more than raw percentages: the full metric climbing during ordinary traffic says the queue behind the scheduler is growing, whatever the instantaneous steal number claims. Two independent gauges agreeing is stronger evidence than either alone.

Where the contention originates: a co-tenant running sustained batch jobs, an oversold node, or your own vCPUs pinned onto busy physical threads. The scheduler documents the accounting, never the culprit. Exclusive metal retires the class of problem by construction — the 9950X in Forge or the EPYC in Summit answers to your cron alone, and steal ceases to be a column anyone reads.

The classic blunder is measuring during your own compile — naturally the vCPU is contested; you scheduled the work. Sample idle-period steal, or steal during your production peak while you are demonstrably not the author. If the number holds above a few percent for a week, the slice is the wrong garment — and the remedy is either a quieter host or a different class, which the measurements themselves will disambiguate.

Memory is binary: resident, swapped, ECC or not

Memory pressure never introduces itself as a memory problem — it arrives costumed as a storage problem. The instant the resident set outgrows plan RAM, the kernel pages to NVMe, and every sluggish-disk investigation that follows is actually a not-enough-RAM investigation wearing a disguise. Swap on fast local storage conceals the scene of the crime with remarkable conviction.

The telltale lives in the paging columns: free -m for the headline, vmstat 1 for the si and so columns — sustained page-in activity under ordinary load means the working set no longer fits. The kernel's tunables (documented in the admin guide — VM sysctl documentation) can reduce the appetite — vm.swappiness=10 is the conventional opening move — but tunables ration the pain; they manufacture no capacity.

ECC is the second binary. Titan carries 32 GB DDR5 ECC and every dedicated tier carries ECC as standard equipment, because a flipped bit inside a database index or a chainstate ledger is the corruption that surfaces weeks later wearing no return address. On slices the ECC story belongs to the host and its brochure; on metal it is yours to prove — dmidecode -t memory reads each module's error-correcting type straight out of the firmware tables, and 32 GB DDR5 ECC on Forge occupies the same price bracket as the largest VPS.

A subtlety worth naming: the page cache complicates the naive reading. Memory shown as used is often cache the kernel can surrender instantly, while the dangerous number is the anonymous, unswappable working set your database actually demands. Compare available memory against the sum of working sets at peak, not against the used column — operators who read the wrong column buy the wrong upgrade, then wonder why nothing improved.

The blunder: bolting on more swap and tuning swappiness forever — converting a capacity shortfall into a latency complaint with extra steps. Read the columns first: if swap-out runs non-zero at your normal peak, resize the plan or relocate the workload, because the memory column renders its verdict before the processor column does, more days than not.

NVMe queues: when storage is the product

For most sites the disk is scenery; for databases, mail spools and chainstate, the storage queue is the merchandise. The slice's failure mode is not capacity but contention: your fsync waits behind a neighbor's bulk import on a shared pool, and the latency graph learns secrets your application never volunteered. Throughput benchmarks will not warn you — the injury is in the tail, not the average.

Interrogate what the workload truly does: fio with random-read and random-write profiles rather than a sequential dd stunt — the project documents job files for exactly this interrogation (fio repository). Databases survive on small random writes plus commit latency; media libraries gorge on sequential throughput. A slice that glitters in sequential tests can still buckle under the sync-heavy cadence a Postgres or a bitcoind produces every second of its life. iostat -x 1 during your ordinary peak supplies the live counterpart — the await column is the queue speaking aloud, and a device pinned at 100% util while latency climbs is contention made visible.

The dedicated ladder answers with quantity and with sovereignty: Forge carries 2×1 TB NVMe, Summit 2×2 TB, Monolith 4×2 TB on Gen4 with RAID 0/1/5/10 selectable — arrays you architect and rebuild yourself with mdadm, while smartctl and the nvme-cli tools (nvme-cli repository) read the drives' own health diaries. On slices you inherit the pool the host provisioned; on metal the lane, the array and the failure drill all answer to you.

Watch the drive diaries before they watch you: reallocated sectors, media errors and wear indicators surface weeks before a failure completes, which converts the dedicated disk from a lottery ticket into a maintenance item with a schedule. On a slice the equivalent telemetry belongs to the host; on metal the same page that reports the problem also hands you the hot-swap bay to fix it during business hours.

The blunder: sizing by gigabytes when the binding constraint is operations per second or commit latency. Two hundred gigabytes of contested NVMe loses to forty gigabytes of serene local NVMe whenever the workload is transactional. If queue latency is the product, own the queue — that sentence is the entire storage argument for metal, and it is the third of the four deciding numbers.

IPMI and RAID: the two things no VPS plan ships

Lights-out console and array choice belong to metal by architecture, not by marketing: a baseboard controller is a small computer soldered to the board, and no hypervisor tenant can reasonably possess one. If you have never operated a machine that mounts an installer while its operating system lies dead, you have not yet operated metal — IPMI is precisely that, standard equipment on every dedicated tier here (the bare-metal comparison walks the same staircase from the far side).

The console ritual: from your desk, ipmitool sol activate delivers the serial-over-LAN console, boot firmware included, and the ipmitool project documents the entire command set (ipmitool repository). A wedged kernel, a careless firewall line, a saturated volume at three in the morning — each becomes self-service. On virtual, a reinstall is one panel action while the hypervisor keeps breathing; the baseboard console covers every hour when nothing healthy remains.

Arrays are the second exclusivity: Forge and Summit provision two-disk chassis (RAID 0/1), Monolith carries four Gen4 drives with 0/1/5/10 selectable — you choose the bargain between throughput and redundancy with mdadm --create, own the rebuild policy, and rehearse the failure drill before it rehearses you. On slices, the host owns every stratum beneath the virtual disk; on metal the array, its scheduler and its SMART diaries are yours.

Practice the drill while nothing is wrong: pull one disk from a test array, watch the degraded banner, practice the re-add, time the rebuild against your data volume. The rehearsal turns a nocturnal pager event into a procedure with a known duration — and the same drill teaches you which redundancy level your actual write pattern can afford to rebuild from on a weeknight.

The moment this section applies: compliance demands console access, the database must survive a drive funeral, or you operate at hours support queues refuse to acknowledge. Order Forge at $49 list — $39.20 on the annual term — as the doorway: 16c/32t, 32 GB DDR5, 2×1 TB NVMe, 1 Gbps unmetered with DDoS scrubbing included, IPMI credentials arriving with the rack after the customary 2-4 h of provisioning.

Where the price lines cross

On this catalog the crossover is one gap you can carry in your head: the VPS staircase terminates at Titan, $24 list and $19.20 annual-eff, and metal opens at Forge, $49 list and $39.20 annual-eff. Between those two invoices lives the entire strategic question — additional slices, or a socket of your own — and every measurement in the earlier sections exists to answer it without drama.

Beneath the gap, scale sideways: two or three Core slices — $6 list, $4.80 annual-eff each — outdeliver one larger slice for web farms, CI fleets and a-service-per-box layouts, and they fail independently of one another. Order Core at $4.80/mo on the annual term per box and the sideways arithmetic stays cheaper than metal until a single process genuinely craves a whole socket; live resizing covers the rest while one box outgrows its costume.

Above the gap, the deciding evidence is the earlier sections': sustained steal, swap churn at peak, commit latency, console obligations. The 9950X in Forge boosts to 5.7 GHz — single-thread speed the EPYC-based Titan cannot match even at 8 vCPU — so per-core workloads cross the gap noticeably earlier than throughput workloads. Fit the workload's silhouette to the silicon, never the price tag to the budget line.

A useful way to date the decision: price your time. Five slices you never have to think about cost less than one machine you babysit, if the slices genuinely fit; one machine that removes a weekly emergency costs less than five slices that cause it, if they genuinely do not. The invoices are nearly symmetrical around the gap; the operational burden is not, and the burden is the part no plan table prints.

The error: vertical-scaling reflexes aimed in both directions — purchasing Summit (32c/64t, 10 Gbps) to rescue a single-threaded worker one fast core would have cured, or sharding a database across five slices one tranquil NVMe array would have housed. Read the quartet of gauges, settle the class once, and cease paying for either exclusivity you cannot feel or shards you do not require. The gap is one invoice wide; cross it once, deliberately, with evidence.

What a VPS still does better

The catalogue of things virtual does better is longer than people expect, because iteration tempo is itself a performance metric. Rebuilds are a panel click, a fresh box images roughly 60 seconds after the invoice credits, CPU and memory resize live, and snapshots bottle a known-good state ahead of every risky change. Metal accomplishes none of that without procuring a second machine.

The capability list survives intact as well: everything the hypervisor's boundary permits — boot images of your own, containers with full privileges, raw sockets, guests inside guests — stays available without the bigger iron, so Tor relays, mail stacks, tunnel endpoints and pruned chain nodes never need to graduate. The relay documentation presumes nothing grander than a Linux box with bandwidth (Tor relay guide), and WireGuard runs wherever a kernel module lives (WireGuard quickstart): wg-quick up wg0 and the tunnel breathes.

Geography spreads the choice: twelve facilities — Reykjavik, Zurich, Amsterdam, Frankfurt, Stockholm, Helsinki, Oslo, Luxembourg, Hong Kong, Tokyo, Singapore, Taipei — the locations table listing each one's tier, uplink and governing law, with abuse adjudicated under the facility's jurisdiction and Iceland and Switzerland carrying premiums of +20% and +35%. Relocating a workload to another jurisdiction is a panel action on virtual; on metal it is a physical odyssey with a truck in it.

There is also a portfolio argument: a dozen small slices diversify failure in ways one monolith cannot — one tenant's memory leak, one bad deploy, one noisy reindex touches a single cell instead of the whole grid. Architectures that assign a service per box, scatter them across two cities and sleep well rely on exactly this property, and it is unavailable at any price on a single chassis.

The mistake from the other flank: treating metal as the serious option and migrating workloads that rebuild in a minute anyway. If steal, swap, lanes and console all read serene, the slice is not the constraint, and the fast iteration loop you preserve outweighs hardware you never touch. A self-hosted BTCPay checkout is the canonical case: it moves on measurements, never on atmosphere.

Provisioning, checkout and the redeploy reality

No in-place path runs from VPS to exclusive metal — the passage is a redeploy in heavier boots. Choreograph it like the shared-hosting exit: build alongside, copy, swing the records, keep a way back open. The classes deliberately share one billing path so the ladder remains a single decision wide rather than two procurement processes with different paperwork and different regret.

The flow is identical end to end: select plan and term, register with email or token and a 12-character password, receive a live-rate invoice in any of nineteen coins — single-use addresses, no card step, no identity paperwork. VPS provisioning ignites about a minute after the transfer credits; dedicated lands 2-4 hours later once racking and IPMI hand-over complete. Both classes carry unmetered ports and DDoS scrubbing from the same platform team.

The redeploy itself: dump and restore the databases (mysqldump or pg_dump), mirror the trees, re-ticket the pointer for the fresh address — the mail identity travels with the hostname, not the chassis, and the rDNS guide scripts that ticket — then swing records inside a low-traffic window with short TTLs already posted. Keep the origin box alive past the cutover; cancel only after the newcomer has metabolized a full traffic cycle.

Rehearse the dump-restore before the real one: the first restore you ever perform should happen when nothing is broken, on the destination box, against a copy that does not matter. The rehearsal surfaces the two classic surprises — character-set mismatches and version gaps — while they are still free, instead of at the cutover hour when every minute of the reversal span is already spoken for.

The canonical failure: swinging everything in one evening because the new machine feels quick, then discovering the one cron nobody inventoried was still writing to the elderly disk. Inventory first, cut in stages, validate each stage before the next. The redeploy is an errand, not a milestone — the classes are two rungs on one ladder, and one invoice pays for whichever rung the evidence selects.

The VPS-to-dedicated switch, in the order to run it

Run the measurements ahead of the desire: a week of vmstat 1 for the steal baseline, free -m plus the swap columns at your ordinary peak, fio profiles against the storage lanes, and a candid inventory of console and array obligations. Evidence first — the ladder only makes sense from the measured rung you are truly standing on, not the one aspiration points at.

If the readings come back serene, scale sideways or resize instead: an additional slice, a live CPU and memory bump, one more address to quarantine duties. If steal holds above a few percent, swap churns at peak, commit latency owns your p99, and the console has become a requirement — select the tier: Forge for single-socket tempo and 2×1 TB, Summit for 32 cores and 10 Gbps, Monolith for dual sockets, 4×2 TB Gen4 arrays and 25 Gbps behind the L3/L7 scrubber.

Place the order, and while the rack crew spends its couple of hours, prepare the landing: export the databases, mirror the file trees, stage configurations, re-ticket pointers for the incoming addresses. Provisioning ends when the console credentials arrive — verify them before any data lands, assemble or mount the array, and only then commence the copy. A console check costs five minutes; skipping one costs the evening you discover the array is not the shape you assumed.

Swing in stages inside a quiet hour: DNS records with their TTLs pre-shortened, mail logs and application errors watched, the origin box retained until the safety span closes, cancelled after one whole demand cycle. Then re-run the same battery on metal too — steal has vanished, but swap and queue mathematics have not — and file the numbers where the next audit will find them.

The discipline is the deliverable: the same gauging ritual that justified the move becomes the maintenance habit that keeps the next transition a Tuesday instead of a crisis with a war story attached. Boxes age, workloads drift, and those readings move with them — rerun it monthly, and whichever rung of the ladder you occupy will be the one the evidence chose, not the one inertia did.

Can I start on a VPS and move to dedicated later?

Yes, though the passage is a redeploy, not an upgrade: copy the data, swing the DNS during a quiet window, and hold the old box through a rollback window. No in-place route to exclusive metal exists, so budget an afternoon for the move rather than a reboot and a hopeful glance.

Which class provisions faster?

VPS, by hours: a fresh box images roughly a minute after the invoice credits. Dedicated needs 2-4 hours first for racking and IPMI hand-over, so stage the data transfer while the rack crew works and verify the console before copying anything at all.

Can I pay for a dedicated server with crypto?

Yes — both classes draw on the same nineteen-coin checkout: XMR and BTC lead, the seven USDT networks follow, then LTC, DOGE, DASH, ADA and the remainder. The invoice mathematics is tier-independent, addresses are single-use, and the live rate applies at the moment of payment.

Do I lose DDoS filtering when I move to metal?

No — L3/L4 scrubbing runs on dedicated tiers too, and Monolith adds an L3/L7 scrubber. What you gain with the move is IPMI, so a wedged box is reimaged out-of-band instead of becoming a support ticket at the worst possible hour of the night.

Does the annual discount apply to dedicated too?

Yes — the 20 percent annual discount applies to the USD list price across the catalog: Forge at $39.20, Summit at $71.20, Monolith at $119.20 monthly-equivalent. The three-month term takes 10 percent if a shorter commitment suits better, and the discount lands before any coin conversion.

Primary sources

More ways to pay

Pay with Bitcoin · Pay with Monero · Pay with USDT (TRC-20/ERC-20/SPL) · Pay with Litecoin · Pay with Ethereum · Pay with Solana · Pay with x402 · Pay with Dogecoin · Pay with XRP · Pay with TRX · Monero on bare metal · Dedicated servers with crypto · Pick the jurisdiction first.

Ready to launch?

Build the box — VPS or bare metal — create the password, pay the invoice that follows.