Quick Answer: Best Laravel VPS
Hostinger at $6.49/mo — 4GB RAM (enough for the full stack), NVMe at 65K IOPS, fastest PHP execution in our tests. Vultr — one-click LEMP stack + 9 US datacenters for geo-proximity. DigitalOcean — best docs + managed MySQL for teams that want to offload database ops. Laravel Forge ($19/mo) works with all three.
Table of Contents
- The Stack That Hit 847 req/sec on a $6.49 VPS
- The RAM Autopsy: Where Every MB Goes
- Octane vs PHP-FPM: The Benchmark Nobody Runs Honestly
- #1. Hostinger — Fastest PHP Execution + NVMe
- #2. Vultr — One-Click LEMP + Geographic Flexibility
- #3. DigitalOcean — Best Ecosystem for Laravel Teams
- #4. Kamatera — Custom Configs for Queue-Heavy Apps
- #5. Linode — Akamai CDN + Phone Support
- The Forge vs DIY Decision
- The Zero-Downtime Deploy Script
- Full Benchmark Comparison
- FAQ
The Stack That Hit 847 req/sec on a $6.49 VPS
I deployed a realistic Laravel 11 application — not a “Hello World” route, but an actual app with 12 routes, 5 Eloquent models with eager-loaded relationships, Redis-cached queries, a queue worker processing email jobs, and a scheduled command running every minute. The route under benchmark load ran User::with('posts.comments')->paginate(20), which exercises Eloquent eager loading, query builder, pagination, and Blade rendering.
Here is the exact stack configuration that hit 847 req/sec on Hostinger’s KVM1 plan ($6.49/mo, 1 vCPU, 4GB RAM, 50GB NVMe):
pm = dynamic
pm.max_children = 8 # (4GB - 1.2GB system) / 50MB per worker ≈ 56, but CPU-bound at 8
pm.start_servers = 3
pm.min_spare_servers = 2
pm.max_spare_servers = 5
pm.max_requests = 500 # Restart workers after 500 requests to prevent memory leaks
# /etc/php/8.3/fpm/conf.d/10-opcache.ini
opcache.enable=1
opcache.memory_consumption=256
opcache.max_accelerated_files=20000
opcache.validate_timestamps=0 # Disable in production! Run artisan optimize after deploy
opcache.jit_buffer_size=100M
opcache.jit=1255
# /etc/mysql/mysql.conf.d/mysqld.cnf
innodb_buffer_pool_size = 512M
innodb_log_file_size = 128M
innodb_flush_log_at_trx_commit = 2 # Trade durability for speed on VPS
max_connections = 50
# Redis: default config, maxmemory 128mb, maxmemory-policy allkeys-lru
# Nginx: worker_processes auto; worker_connections 1024;
With OPcache JIT enabled and opcache.validate_timestamps=0, PHP does not check if files have changed on every request. This alone doubled throughput from 420 to 847 req/sec. The trade-off: you must run php artisan optimize after every deployment. Laravel Forge handles this automatically.
The RAM Autopsy: Where Every MB Goes
I ran ps aux --sort=-%mem on the tuned Hostinger server under load and recorded exactly where the 4GB of RAM went:
| Process | Count | RAM Each | Total | Notes |
|---|---|---|---|---|
| MySQL (innodb_buffer_pool) | 1 | — | 680 MB | 512MB buffer pool + overhead |
| PHP-FPM workers | 8 | 52 MB | 416 MB | Varies by loaded packages (30–80MB) |
| OPcache shared memory | 1 | — | 256 MB | Shared across all workers |
| Redis | 1 | — | 58 MB | Cache + sessions + queue |
| Queue worker (Horizon) | 1 | — | 85 MB | Separate PHP process |
| Nginx | 2 workers | 8 MB | 16 MB | Master + 2 workers |
| OS + systemd + sshd | — | — | 280 MB | Ubuntu 24.04 baseline |
| Scheduler (cron) | 1 | — | 12 MB | Runs artisan schedule:run every minute |
| Total Used | 1,803 MB | — | ||
| Available Headroom | 2,197 MB | For artisan commands, composer, traffic spikes | ||
On a 4GB VPS, the full stack uses 1.8GB with 2.2GB headroom. That headroom absorbs php artisan migrate (150MB spike), composer install during deployment (200–400MB spike), and traffic bursts that spawn additional PHP-FPM workers. On a 1GB VPS, this stack simply does not fit. MySQL alone would consume 68% of total RAM.
php artisan migrate while serving traffic will OOM kill PHP-FPM. I have seen this happen to three client projects. Do not be the fourth.
Octane vs PHP-FPM: The Benchmark Nobody Runs Honestly
Every Octane article shows dramatic speedups. Nobody mentions the production caveats. I tested both on the same Hostinger VPS with the same Laravel application:
| Metric | PHP-FPM (8 workers) | Octane/Swoole (8 workers) | Improvement |
|---|---|---|---|
| Requests/sec (eager-load route) | 847 | 1,380 | +63% |
| Avg response time | 18ms | 7ms | +61% |
| p99 response time | 42ms | 22ms | +48% |
| RAM per worker | 52 MB | 85 MB | +63% more RAM |
| Cold start time | 0ms (per-request bootstrap) | 1,200ms (app bootstraps once) | Different model |
| Deploy restart required? | No — new requests get new code | Yes — must restart all workers | Operational overhead |
| Package compatibility | 100% | ~85% — some packages leak memory | Testing required |
Octane is 63% faster. It also uses 63% more RAM per worker, requires testing every package for memory leaks, and needs process restarts on every deployment. For APIs and high-throughput services where you control every dependency: Octane is transformative. For standard Laravel apps with Horizon, scheduled tasks, and third-party packages: PHP-FPM is more reliable in production and 847 req/sec is more than enough for the vast majority of applications.
#1. Hostinger — Fastest PHP Execution + NVMe ($6.49/mo)
Hostinger won the Laravel benchmark for three reasons. First, 4GB RAM at $6.49 — the only provider on this list where the full production stack (PHP-FPM + MySQL + Redis + Horizon) fits in memory on the entry plan. Second, the NVMe storage at 65K IOPS cuts Composer install from 28 seconds (SSD average) to 12 seconds, and every artisan config:cache / route:cache / view:cache command runs measurably faster. Third, the CPU benchmark score of 4,400 means each PHP-FPM worker processes requests faster than the competition.
The Benchmark Numbers in Context
| Provider | PHP 8.3 req/sec | Composer install | artisan migrate (50 tables) | Queue: 1000 jobs |
|---|---|---|---|---|
| Hostinger | 847 | 12s | 3.2s | 28s |
| Vultr | 780 | 15s | 4.1s | 32s |
| DigitalOcean | 745 | 16s | 4.4s | 34s |
| Kamatera | 720 | 28s | 6.8s | 38s |
| Linode | 695 | 24s | 5.9s | 42s |
The gap between Hostinger (847) and Linode (695) is 22%. For a SaaS with 500 concurrent users, that difference is the line between a responsive application and one where Eloquent relationship loading starts feeling sluggish during peak hours. The Composer install difference (12s vs 28s on Kamatera) matters during deployments: faster installs mean shorter deployment windows and less time where the application is in a transitional state.
The Hostinger Limitations for Laravel
No one-click Laravel setup — you are configuring Nginx, PHP-FPM, MySQL, and Redis manually (or using Forge). Only 2 US datacenter locations. No API for infrastructure automation, which means no Terraform or Pulumi workflows. Renewal pricing is higher than the introductory rate. For a single Laravel application, none of these matter. For a team managing multiple applications with infrastructure-as-code, Vultr or DigitalOcean’s APIs are more practical.
#2. Vultr — One-Click LEMP + Geographic Flexibility ($6/mo)
Deploy Laravel in 90 Seconds
Vultr’s marketplace has a one-click LEMP stack that deploys in under 60 seconds: Ubuntu 24.04, Nginx, MySQL 8, PHP 8.3 with OPcache pre-configured. Run composer create-project laravel/laravel, configure the .env, and you have a running Laravel app. No manual Nginx configuration. No PHP-FPM pool tuning. The defaults are not production-optimal (you should still tune pm.max_children), but they are functional immediately.
The Geography Advantage
9 US datacenters: Atlanta, Chicago, Dallas, Los Angeles, Miami, New York, Seattle, Silicon Valley, Toronto. For a Laravel SaaS with users across the US, deploying in Dallas instead of NYC can reduce TTFB by 30–50ms for Midwest users. Vultr is the only provider on this list with both a one-click LEMP stack and 9 US locations. Laravel Forge supports Vultr natively — connect your API key and Forge provisions optimized Laravel servers automatically.
The RAM Problem at Entry Tier
Vultr’s $6/mo plan has 2GB RAM. That runs Laravel + MySQL + Redis without Horizon, but there is no headroom for artisan commands during traffic. The $24/mo plan (2 vCPU, 4GB) is the realistic Laravel starting point on Vultr. More expensive than Hostinger’s $6.49 for 4GB, but the 2 vCPU and geographic flexibility offset the price difference for applications that need them.
#3. DigitalOcean — Best Ecosystem for Laravel Teams ($6/mo)
The Managed Database Case for Laravel
DigitalOcean’s managed MySQL ($15/mo) eliminates the component that causes the most headaches in Laravel production: the database. Automated backups, point-in-time recovery, failover, and version upgrades — all handled. For a Laravel SaaS where the database is the critical layer, offloading MySQL to a managed service lets you run PHP-FPM and Redis on a smaller, cheaper Droplet without MySQL eating your RAM.
The architecture that works best: $12/mo Droplet (2 vCPU, 2GB) for PHP-FPM + Redis + Nginx, plus $15/mo managed MySQL. Total $27/mo. The Droplet only needs to serve PHP and cache — no MySQL buffer pool consuming 500MB. You get database backups, automatic failover, and the ability to scale the database independently of the application server.
The Documentation Advantage
DigitalOcean’s community tutorials are the de facto standard for “how to deploy Laravel on a VPS.” Their guides cover every layer: server provisioning, Nginx configuration for Laravel with pretty URLs, PHP-FPM pool tuning, Redis setup for Laravel queues, SSL via Let’s Encrypt, and securing the server with UFW. If you are deploying Laravel on a VPS for the first time, start with DigitalOcean’s guides.
The $200 trial credit runs a properly-sized Laravel stack for about 6 weeks — enough to deploy a staging environment, benchmark your application, and verify performance before committing.
#4. Kamatera — Custom Configs for Queue-Heavy Apps ($4/mo+)
When Your Queue Workers Need Different Hardware Than Your Web Server
Laravel queue workers and web servers have fundamentally different resource profiles. Web serving is I/O-bound: PHP-FPM waits for MySQL queries and Redis responses. Queue workers are CPU-bound: processing emails, resizing images, generating PDFs, running reports. Kamatera lets you build separate servers with exact specs for each role:
| Server Role | Kamatera Config | Monthly Cost | Why This Config |
|---|---|---|---|
| Web server (PHP-FPM + Nginx) | 1 vCPU / 4GB RAM / 30GB SSD | ~$14 | RAM for PHP-FPM workers + OPcache |
| Queue worker (Horizon) | 4 vCPU / 2GB RAM / 20GB SSD | ~$18 | CPU for processing, minimal RAM needed |
| Database (MySQL) | 2 vCPU / 8GB RAM / 50GB SSD | ~$28 | RAM for buffer pool, CPU for queries |
| Total: 3-server Laravel architecture | ~$60/mo | Each component optimized for its role | |
On a fixed-plan provider, matching these specs would cost $72–96/mo because you would be forced into plans with resources you do not need. Kamatera’s SATA SSD (18K IOPS) is its weakness — Composer installs take 28 seconds versus 12 on Hostinger’s NVMe. For the web server component, this matters. For the queue worker, disk speed is irrelevant.
#5. Linode — Akamai CDN + Phone Support ($5/mo)
The CDN Integration for Laravel Asset Delivery
Laravel applications that serve compiled CSS/JS bundles, user-uploaded images, and file downloads benefit from Linode’s Akamai CDN integration. Instead of every asset request hitting your Nginx server, Akamai serves cached assets from its edge network. For a Laravel app with php artisan storage:link serving user uploads, this offloads a significant portion of requests from your VPS. Configure ASSET_URL in .env to point to the Akamai CDN, and Laravel automatically generates CDN URLs for all assets compiled by Vite or Mix.
Phone Support When Deployments Go Wrong
Linode is the only provider on this list with phone support at the entry price tier. When a Laravel deployment breaks at 11 PM and you have already exhausted your debugging options, being able to call someone who can check your server-level configuration (Nginx errors, PHP-FPM crashes, disk full) is valuable in a way that ticket-based support at 4-hour response times is not. 695 req/sec is the lowest in our benchmark, but for many Laravel apps, reliable support matters more than an extra 150 req/sec.
The Forge vs DIY Decision
Laravel Forge ($19/mo) automates everything I described in the stack configuration section. The question is whether that automation is worth $228/year.
| Task | DIY Time | Forge Time | Frequency |
|---|---|---|---|
| Initial server provisioning | 2–3 hours | 5 minutes | Once |
| SSL certificate setup + renewal | 30 min + monitoring | 1 click (auto-renewal) | Every 90 days |
| Zero-downtime deployment | Write deploy script (1 hr) | Push to Git (auto) | Every deploy |
| Queue worker supervision | Configure supervisor (30 min) | Toggle in dashboard | Once |
| PHP version upgrade | 1–2 hours | 1 click | Yearly |
| Security patches | Monitor + apply (30 min/mo) | Automatic | Monthly |
| Annual time investment | ~15 hours/year | ~1 hour/year | — |
At $50/hr freelance rate: DIY costs $750/year in time. Forge costs $228/year. At $25/hr: DIY costs $375, Forge costs $228. The break-even is roughly $15/hr. If your time is worth more than $15/hr, Forge pays for itself. If you are learning server administration for career development, DIY is educational and saves $228/year.
Forge works natively with Hostinger, Vultr, DigitalOcean, Linode, and custom servers (including Kamatera). It also supports Envoyer-style zero-downtime deployments, database backups to S3, and multi-server load balancing.
The Zero-Downtime Deploy Script (If You Skip Forge)
For those going DIY, here is the symlink-based deployment script I use for production Laravel deployments:
# deploy.sh — Zero-downtime Laravel deployment
set -e
REPO="git@github.com:you/your-app.git"
BASE="/var/www/app"
RELEASE="$BASE/releases/$(date +%Y%m%d%H%M%S)"
SHARED="$BASE/shared"
# Clone fresh release
git clone --depth 1 "$REPO" "$RELEASE"
# Link shared resources (.env, storage, vendor cache)
ln -sf "$SHARED/.env" "$RELEASE/.env"
ln -sf "$SHARED/storage" "$RELEASE/storage"
# Install dependencies (--no-dev for production)
cd "$RELEASE" && composer install --no-dev --optimize-autoloader --no-interaction
# Cache everything
php artisan config:cache
php artisan route:cache
php artisan view:cache
php artisan event:cache
# Run migrations
php artisan migrate --force
# Atomic symlink switch (zero downtime)
ln -sfn "$RELEASE" "$BASE/current"
# Reload PHP-FPM (not restart — graceful)
sudo systemctl reload php8.3-fpm
# Restart queue workers to pick up new code
php artisan queue:restart
# Cleanup: keep last 5 releases
ls -dt "$BASE/releases"/* | tail -n +6 | xargs rm -rf
echo "Deployed: $RELEASE"
Point Nginx’s root to /var/www/app/current/public. The ln -sfn command atomically switches the symlink — users see zero downtime. If the new release breaks, switch back: ln -sfn /var/www/app/releases/PREVIOUS /var/www/app/current.
Full Laravel Benchmark Comparison
| Provider | 4GB Plan | PHP 8.3 req/sec | Octane req/sec | Composer Install | 1000 Jobs | Storage | US DCs | Forge |
|---|---|---|---|---|---|---|---|---|
| Hostinger | $6.49 | 847 | 1,380 | 12s | 28s | NVMe | 2 | ✓ |
| Vultr | $24 | 780 | 1,245 | 15s | 32s | NVMe | 9 | ✓ |
| DigitalOcean | $24 | 745 | 1,180 | 16s | 34s | NVMe | 2 | ✓ |
| Kamatera | ~$14 | 720 | 1,150 | 28s | 38s | SSD | 4 | Custom |
| Linode | $24 | 695 | 1,090 | 24s | 42s | SSD | 9 | ✓ |
All benchmarks: Laravel 11, PHP 8.3 with OPcache+JIT, Ubuntu 24.04, 4GB RAM. req/sec measured with Apache Benchmark at 100 concurrent connections against an Eloquent eager-loading route. Queue jobs include email dispatch, image resize, and report generation.
Which Laravel VPS Should You Choose?
- Best overall: Hostinger — 4GB RAM for $6.49/mo, fastest PHP execution, NVMe. The only plan where the full stack fits at the entry price
- Best for geographic distribution: Vultr — 9 US DCs + one-click LEMP. Higher price for 4GB but best deployment experience
- Best for teams: DigitalOcean — managed MySQL + best docs + $200 trial. Ideal for Laravel projects with dedicated ops support
- Best for queue-heavy apps: Kamatera — custom CPU/RAM per server role. Separate web and worker configurations at lower total cost
- Best support: Linode — phone support + Akamai CDN. For teams that need a human when deployments break
Related guides: Best VPS for Python • Best VPS for Node.js • Best VPS for Docker • Best VPS for Databases • Best NVMe SSD VPS • Best VPS for Development
Frequently Asked Questions
How much RAM does Laravel actually need on a VPS?
A production stack (Nginx + PHP-FPM + MySQL + Redis) consumes ~1.2GB before your application code loads. Each PHP-FPM worker adds 30–80MB. 2GB is the absolute minimum without Horizon. 4GB is the comfortable baseline for PHP-FPM + MySQL + Redis + queue worker. 8GB for apps running Horizon with multiple workers and heavy Eloquent relationships. On 1GB, running artisan migrate during traffic will OOM kill PHP-FPM.
Should I use Laravel Octane or PHP-FPM?
PHP-FPM for most apps. Octane (Swoole/RoadRunner) is 40–65% faster by keeping the app in memory, but uses more RAM per worker, requires restart on deploy, and ~15% of packages have memory leak issues. Use Octane for high-throughput APIs where you control every dependency. Use PHP-FPM for standard Laravel apps with Horizon, scheduled tasks, and third-party packages. 847 req/sec on PHP-FPM is more than enough for most applications.
Is Laravel Forge worth $19/month?
If your time is worth more than $15/hr, yes. Forge automates provisioning, SSL, deployments, queue supervision, PHP upgrades, and security patches. DIY takes ~15 hours/year in maintenance. At $50/hr, that is $750 in time vs $228 for Forge. It works with Hostinger, Vultr, DigitalOcean, Linode, and custom servers. For agencies managing multiple Laravel apps, it is essentially mandatory.
Do I need Redis for Laravel on VPS?
Not strictly required, but running without it is like driving without power steering. Redis replaces file-based cache and session drivers (which hit disk every request), speeds up queue processing 3–5x over the database driver, and enables real-time broadcasting via Echo. It uses 30–60MB RAM — a worthwhile trade-off. Skip Redis only on very low-traffic apps where you are minimizing RAM at all costs.
PHP 8.3 vs 8.2 — how much faster?
About 5–8% in our Laravel benchmarks. Same app on Hostinger: 847 req/sec on PHP 8.3 vs 791 on PHP 8.2 (7.1% improvement). The gains come from typed class constants, readonly property optimizations, and internal engine refinements. It is free performance. Always pair with OPcache enabled — without OPcache, the PHP version difference is irrelevant compared to the 2–3x improvement OPcache provides.
Can I run Laravel on a $5 VPS with 1GB RAM?
Yes, with painful compromises. Use SQLite instead of MySQL (saves ~300MB), skip Redis (file cache, 3–5x slower queues), limit PHP-FPM to 2 workers, and never run artisan commands during traffic. This handles ~20 concurrent requests. For anything beyond a personal project, 4GB is the minimum I recommend. The $6.49 Hostinger plan with 4GB RAM eliminates all these compromises for $1.49 more per month.
How do I deploy Laravel without downtime?
Use symlink-based deployments: deploy each version to a timestamped directory under /releases/, run composer install and artisan caches, then atomically switch the current symlink with ln -sfn. Reload (not restart) PHP-FPM and run queue:restart. The symlink switch is instant — zero user-visible downtime. Keep 3–5 old releases for instant rollback. Laravel Forge and Envoyer automate this entire process.
Our Top Pick for Laravel VPS
Hostinger at $6.49/mo delivered 847 req/sec with the full Laravel stack on 4GB RAM + NVMe. For teams wanting managed databases, DigitalOcean’s $200 trial covers weeks of testing.