# DiscountOffer.Store
> Get the best Hostinger deals with coupon WEBHOST2026. Compare web, cloud, VPS and WordPress hosting, pick a 12, 24 or 48-month plan and unlock your exclusive discount link instantly. DiscountOffer.Store is an independent Hostinger referral partner, not Hostinger itself.
## Key facts
- Coupon code: WEBHOST2026. It adds an extra 20% off Hostinger's sale price on eligible new hosting plans. Last verified at a real checkout in October 2026.
- It works on web, WordPress, cloud and VPS hosting and the Website Builder. Domains bought on their own, add-ons and renewals of existing plans usually aren't discounted.
- How to apply: open Hostinger through https://www.discountoffer.store (the code is pre-attached) or type WEBHOST2026 in the "Have a coupon code?" box at checkout.
- The 48-month term has the lowest monthly price. Plans renew at a higher standard rate after the first term.
- Web Hosting: from $2.49/mo (Single, 48-month term, before the coupon)
- WordPress Hosting: from $2.49/mo (Premium WordPress, 48-month term, before the coupon)
- VPS Hosting: from $4.99/mo (KVM 1, 48-month term, before the coupon)
- Hostinger offers a 30-day money-back guarantee on hosting plans; domain registrations aren't refundable.
- Prices on this site are indicative USD figures; the exact price, currency and tax are shown at Hostinger's checkout. Local stores exist for many countries, including Pakistan (PKR, JazzCash) and India (INR, UPI).
- DiscountOffer.Store is an independent Hostinger referral partner, not Hostinger. It earns a commission when people buy through its links, at no extra cost to them.
---
# How to point a domain to your Hostinger VPS (A records, step by step)
URL: https://www.discountoffer.store/blog/point-domain-to-hostinger-vps
Published: 2026-10-17 · Category: Tutorials
> Find your VPS IP, add the right A and AAAA records whether your domain is at Hostinger, GoDaddy or Namecheap, and check propagation before you ask Let's Encrypt for a certificate.
## Two ways to connect a domain
A domain reaches your server through DNS records. You can either keep DNS where it is and add an A record that points at the VPS, or move the whole domain's DNS to Hostinger by changing nameservers and then add the records in hPanel.
For a single VPS the first option is quicker and less disruptive: your email records and anything else on the domain stay untouched. Change nameservers only if you want everything managed in one dashboard.
| Option | What you change | Best when |
| --- | --- | --- |
| Add A records | Two records at your current DNS host | The domain already has email or other services set up |
| Switch nameservers | Nameservers at your registrar, then records in hPanel | You want domain, DNS and VPS in one Hostinger account |
## Step 1 — Find your VPS IP address
In hPanel, open VPS, pick your server and look at the overview. You'll see an IPv4 address (four numbers, like 203.0.113.10) and usually an IPv6 address as well. Copy the IPv4 one; that's the one every record below needs.
> You can confirm the address from the server itself with `curl -4 ifconfig.me` once you're logged in over SSH.
## Step 2 — Add the records
Whichever DNS host you use, the records are the same. In hPanel that's Domains → your domain → DNS / Nameservers. At GoDaddy it's the DNS tab of the domain, at Namecheap it's Advanced DNS.
Before you add anything, delete any existing A records for `@` and `www` that point somewhere else, such as a parking page. Two A records with different IPs means visitors land on either server at random.
| Type | Name / Host | Value | TTL |
| --- | --- | --- | --- |
| A | @ | Your VPS IPv4 | 300 while testing, 3600 after |
| A | www | Your VPS IPv4 | 300 while testing, 3600 after |
| AAAA (optional) | @ | Your VPS IPv6 | Same as above |
> Only add an AAAA record if your web server actually listens on IPv6. A stale or wrong AAAA record is the classic reason Certbot fails with a timeout even though the A record looks perfect, because Let's Encrypt prefers IPv6 when it's offered.
## Step 3 (optional) — Switch nameservers to Hostinger
If you'd rather manage DNS in hPanel, set the nameservers at your registrar to the two Hostinger shows you in hPanel (at the time of writing, ns1.dns-parking.com and ns2.dns-parking.com). Then add the records from Step 2 inside hPanel.
Copy any MX, TXT (SPF, DKIM, verification) and CNAME records across first. Changing nameservers replaces the whole zone, so anything you don't recreate stops working, and email is usually the first thing to break.
## Step 4 — Check propagation
Most changes are visible within minutes, though resolvers that cached the old record can hold it until the old TTL runs out. Nameserver changes can take up to 24 to 48 hours.
Both commands should print your VPS IP:
```bash
dig +short example.com A
dig +short www.example.com A
# Ask a public resolver directly, bypassing your local cache
dig +short example.com A @1.1.1.1
dig +short example.com AAAA @1.1.1.1
```
> Don't run Certbot until `dig` returns the right address from a public resolver. Let's Encrypt rate-limits failed validations, so guessing wastes attempts.
## Step 5 — Set the reverse DNS (PTR) if you'll send email
If the server sends mail directly (password resets, contact forms), set a PTR record so the IP resolves back to your hostname. Hostinger lets you edit it from the VPS settings in hPanel. Without it, Gmail and Outlook are far more likely to bin your messages.
If you send through a provider like Hostinger Email or a transactional service, you can skip this.
- [Next: secure the server before going live](https://www.discountoffer.store/blog/secure-hostinger-vps-checklist)
- [Then deploy your Next.js app](https://www.discountoffer.store/blog/deploy-nextjs-app-on-hostinger-vps)
## FAQ
### How long does it take for a domain to point to my VPS?
A new A record usually works within a few minutes. If you changed nameservers, allow up to 24 to 48 hours, although it is often much faster.
### Should www be an A record or a CNAME?
Either works. A CNAME from www to the root domain means you only update one record if the IP ever changes; two A records are simpler to reason about. Don't create both for the same name.
### Do I need to buy the domain from Hostinger?
No. Any registrar works. You only need access to its DNS settings to add the A records.
### Why does my domain still show the old site?
Your computer or ISP has the old record cached. Check with `dig @1.1.1.1`, flush your local DNS cache, or try from mobile data. If the public resolver shows the new IP, it's only a cache.
---
# Secure a new Hostinger VPS: the 10-minute checklist
URL: https://www.discountoffer.store/blog/secure-hostinger-vps-checklist
Published: 2026-10-17 · Category: Tutorials
> SSH keys, no root or password logins, a firewall, Fail2ban, automatic security updates and snapshots. The minimum to do before a fresh VPS goes on the internet, with copy-paste commands.
## Why do this first
A new server with a public IP gets automated SSH login attempts within minutes of booting. That isn't aimed at you; bots scan the whole IPv4 range all day. The steps below shut out nearly all of that noise and take about ten minutes.
Do them in order, and keep your current SSH session open until the end. If a change locks you out, the open session is how you undo it.
## 1. Update everything
OS templates are built ahead of time, so a fresh server is usually a few patches behind.
```bash
apt update && apt full-upgrade -y
reboot # if a new kernel was installed
```
## 2. Create a non-root user with your SSH key
Day-to-day work happens as a normal user with sudo. If you added an SSH key when you created the VPS, it's in root's `authorized_keys`; copy it across.
```bash
adduser deploy
usermod -aG sudo deploy
rsync --archive --chown=deploy:deploy ~/.ssh /home/deploy/
```
No key yet? Make one on your laptop, then copy it up:
```bash
ssh-keygen -t ed25519 -C "you@laptop"
ssh-copy-id deploy@YOUR_SERVER_IP
```
> Open a second terminal and confirm `ssh deploy@YOUR_SERVER_IP` works and `sudo -v` accepts your password before going any further.
## 3. Turn off root and password logins
On Ubuntu 24.04, put your settings in a drop-in file instead of editing `sshd_config`. One detail catches people out: for each setting, sshd uses the first value it reads, and drop-ins load in alphabetical order. Cloud images often ship a `50-cloud-init.conf` that turns password login on, so name your file with a lower number so it's read first.
/etc/ssh/sshd_config.d/00-hardening.conf
```bash
sudo tee /etc/ssh/sshd_config.d/00-hardening.conf > /dev/null <<'EOF'
PermitRootLogin no
PasswordAuthentication no
KbdInteractiveAuthentication no
PubkeyAuthentication yes
EOF
sudo sshd -t # syntax check, prints nothing when OK
sudo sshd -T | grep -E 'permitrootlogin|passwordauthentication'
sudo systemctl restart ssh
```
> Test a fresh login as `deploy` in a new terminal now. If it fails, fix it from the session you still have open.
## 4. Firewall: allow only what you serve
UFW is the simplest firewall on Ubuntu. Allow SSH before enabling it, then open web ports. Hostinger also has a network firewall in hPanel's VPS settings; using both is fine, and the hPanel one blocks traffic before it ever reaches your server.
```bash
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw --force enable
sudo ufw status verbose
```
> Docker writes its own iptables rules and bypasses UFW for published ports. A container started with `-p 5432:5432` is reachable from the internet even though UFW says otherwise. Publish to localhost only, for example `-p 127.0.0.1:5432:5432`.
## 5. Fail2ban for repeated failed logins
With password logins off, brute force can't succeed, but Fail2ban still keeps your logs readable and blocks noisy scanners. The default SSH jail is enough.
```bash
sudo apt install -y fail2ban
sudo tee /etc/fail2ban/jail.local > /dev/null <<'EOF'
[sshd]
enabled = true
backend = systemd
maxretry = 5
bantime = 1h
EOF
sudo systemctl enable --now fail2ban
sudo fail2ban-client status sshd
```
## 6. Automatic security updates
Unattended-upgrades installs security patches every day without touching anything else. Most Ubuntu images have it already; this makes sure it's on.
```bash
sudo apt install -y unattended-upgrades
sudo dpkg-reconfigure -plow unattended-upgrades # choose "Yes"
```
## 7. Snapshots and real backups
Take a snapshot in hPanel now that the server is clean, and again before any risky upgrade. Restoring takes minutes.
A snapshot isn't an off-site backup, though. Dump your database on a schedule and copy it somewhere else, such as object storage or another machine, so one account problem can't take out both the server and its backup.
- Snapshot before major upgrades or config changes.
- Nightly database dump with a cron job, kept off the server.
- Test a restore once. A backup you've never restored is a guess.
## Quick checklist
Print this, or keep it in your repo's README:
- System fully updated
- Non-root sudo user with SSH key
- Root login and password login disabled, tested in a new session
- UFW on: only 22, 80 and 443 open
- Docker ports published to 127.0.0.1 only
- Fail2ban running
- Unattended security upgrades on
- Clean snapshot taken; off-server database backups scheduled
- [Point your domain at the server](https://www.discountoffer.store/blog/point-domain-to-hostinger-vps)
- [Deploy a Next.js app on it](https://www.discountoffer.store/blog/deploy-nextjs-app-on-hostinger-vps)
- [Set up push-to-deploy with GitHub Actions](https://www.discountoffer.store/blog/github-actions-deploy-to-hostinger-vps)
## FAQ
### Is a Hostinger VPS secure by default?
The platform side is (DDoS filtering, isolated KVM virtualisation), but the operating system is yours to manage. A fresh image allows root login and has no firewall rules of your own, so run through this checklist before deploying anything.
### Should I change the SSH port from 22?
It reduces log noise but adds little real security once password login is off. On Ubuntu 24.04 SSH uses socket activation, so changing the port means editing the ssh.socket unit too. Most people are better off leaving 22 and using keys plus Fail2ban.
### I locked myself out. What now?
Use the browser terminal in hPanel's VPS dashboard. It connects through the console, not SSH, so you can fix the sshd config or firewall from there.
### Do I need both UFW and the hPanel firewall?
No, but both is a sensible belt-and-braces setup. The hPanel firewall filters traffic before it reaches the VM; UFW protects you if you ever move the server or change provider.
---
# Auto-deploy to a Hostinger VPS with GitHub Actions (push to deploy)
URL: https://www.discountoffer.store/blog/github-actions-deploy-to-hostinger-vps
Published: 2026-10-17 · Category: Tutorials
> Every push to main deploys your app to the VPS. A dedicated SSH key, pinned host keys, a locked-down forced command and a workflow under 30 lines, with no third-party actions.
## How it fits together
The simplest reliable setup has GitHub do nothing clever. On every push to `main`, a workflow opens an SSH connection to your VPS and runs the deploy script that already lives there. The server pulls the code, builds and restarts. If the script works when you run it by hand, it works from CI.
This guide assumes you have a working `deploy.sh`, like the one at the end of our Next.js guide. The same pattern works for Laravel, Django or anything else; only the script changes.
- [The Next.js deploy guide, with deploy.sh](https://www.discountoffer.store/blog/deploy-nextjs-app-on-hostinger-vps)
## Step 1 — Make a key just for CI
Never reuse your personal SSH key. Make a separate one with no passphrase, so you can revoke CI access without touching your own login.
On your laptop:
```bash
ssh-keygen -t ed25519 -N "" -C "github-actions" -f ./gha_deploy
# gha_deploy -> private key, goes into a GitHub secret
# gha_deploy.pub -> public key, goes onto the server
```
## Step 2 — Allow the key to run one command only
Add the public key to the deploy user's `authorized_keys` with a forced command. Whatever the client asks for, the server runs only `deploy.sh`. If the private key ever leaks, the worst anyone can do is trigger a deploy of your own code.
On the VPS, as deploy, add one line (all on a single line):
```bash
nano ~/.ssh/authorized_keys
command="/var/www/myapp/deploy.sh",no-port-forwarding,no-agent-forwarding,no-X11-forwarding,no-pty ssh-ed25519 AAAA...your-public-key... github-actions
```
> Private repo? The server also needs read access to pull. Add a separate read-only deploy key under the repo's Settings → Deploy keys, generated on the server with `ssh-keygen -t ed25519`, and clone over SSH instead of HTTPS.
## Step 3 — Store the secrets in GitHub
In the repository, open Settings → Secrets and variables → Actions and add three secrets. Pinning the host key matters: without it, the workflow would trust whatever machine answers on that IP.
| Secret | Value |
| --- | --- |
| SSH_HOST | Your VPS IP or domain |
| SSH_KEY | The full contents of gha_deploy (private key) |
| SSH_KNOWN_HOSTS | The line printed by ssh-keyscan |
Get the value for SSH_KNOWN_HOSTS:
```bash
ssh-keyscan -t ed25519 YOUR_SERVER_IP
```
## Step 4 — The workflow
Commit this file. `concurrency` queues deploys so two quick pushes can't build on top of each other.
.github/workflows/deploy.yml
```yaml
name: Deploy
on:
push:
branches: [main]
workflow_dispatch:
concurrency:
group: production
cancel-in-progress: false
jobs:
deploy:
runs-on: ubuntu-latest
timeout-minutes: 15
steps:
- name: Configure SSH
run: |
mkdir -p ~/.ssh
echo "${{ secrets.SSH_KEY }}" > ~/.ssh/id_ed25519
chmod 600 ~/.ssh/id_ed25519
echo "${{ secrets.SSH_KNOWN_HOSTS }}" > ~/.ssh/known_hosts
- name: Deploy
run: ssh deploy@${{ secrets.SSH_HOST }}
```
> There's no command after the host because the forced command in authorized_keys decides what runs. `workflow_dispatch` adds a Run workflow button, so you can redeploy without pushing.
## Step 5 — Make failures visible
Because `deploy.sh` starts with `set -euo pipefail`, a failed build exits non-zero, the SSH command fails, and the workflow goes red. GitHub emails you, and the live app keeps running the previous build because PM2 was never restarted.
- Run tests in an earlier job and add `needs: test` to the deploy job, so broken code never reaches the server.
- Keep the build on the server only while builds are quick. If they start eating the VPS's CPU while it serves traffic, build in Actions and rsync the output instead.
- Add a protected environment in GitHub if you want a manual approval before production deploys.
## Troubleshooting
The errors you're most likely to see, and what they mean:
| Error | Cause and fix |
| --- | --- |
| Host key verification failed | SSH_KNOWN_HOSTS is empty or for a different key type. Re-run ssh-keyscan and paste the whole line. |
| Permission denied (publickey) | The public key isn't in the deploy user's authorized_keys, or the file is group-writable. Run chmod 600 ~/.ssh/authorized_keys. |
| pm2: command not found | Non-interactive SSH doesn't load your shell profile. Use the full path from `which pm2` inside deploy.sh. |
| Build killed / exit 137 | Out of memory during the build. Add swap, or build in Actions instead. |
## FAQ
### Can I use GitHub Actions with Hostinger shared hosting?
Yes, but over FTP or SFTP rather than SSH commands: build in Actions, then upload the output folder. Shared hosting can't run a build or a long-lived process for you.
### Is it safe to store an SSH key in GitHub secrets?
Secrets are encrypted and masked in logs. Pair that with a CI-only key restricted by a forced command, and a leaked key can only trigger a deploy of your own code.
### Does this cost anything?
GitHub Actions includes free minutes for private repos and is free for public ones. This workflow uses well under a minute per deploy, since the build runs on your VPS.
---
# Self-host n8n on a Hostinger VPS (Docker, HTTPS, backups)
URL: https://www.discountoffer.store/blog/self-host-n8n-on-hostinger-vps
Published: 2026-10-17 · Category: Tutorials
> Run your own n8n automation server for a flat monthly price: the one-click template, or a Docker Compose setup with automatic HTTPS, plus updates, backups and which KVM plan to pick.
## Why self-host n8n
n8n is a workflow automation tool, in the same space as Zapier and Make. You connect apps, add logic, and let it run. The hosted version charges by workflow executions; self-hosted, you pay for the server and run as many executions as it can handle.
n8n is distributed under its Sustainable Use License, which allows self-hosting for your own and your company's internal use. If you plan to resell n8n as a service, read the licence first.
## Which plan you need
n8n itself is light, but workflows that process files, call AI models or loop over large lists use memory quickly.
| Plan | Good for |
| --- | --- |
| KVM 1 (1 vCPU, 4 GB) | Personal automations and a small team's workflows on the default SQLite database |
| KVM 2 (2 vCPU, 8 GB) | Many active workflows, Postgres alongside n8n, heavier file or AI processing |
| KVM 4 and up | Queue mode with Redis and multiple workers |
## Option A — The one-click n8n template
Hostinger offers n8n as a VPS OS template. Choose it when you create the server (or reinstall an existing one from the VPS settings) and you get n8n running in Docker without touching the command line.
It's the fastest route and fine for most people. Choose Option B if you want to see every moving part, run n8n next to other apps, or control exactly which version you're on.
> Reinstalling a VPS with a template wipes the disk. Take a snapshot first if anything on it matters.
## Option B — Docker Compose with automatic HTTPS
Start from a plain Ubuntu 24.04 server that you've already secured, with an A record for a subdomain such as `n8n.example.com` pointing at it. Caddy handles HTTPS: it requests and renews the Let's Encrypt certificate on its own.
Install Docker and create the project folder:
```bash
curl -fsSL https://get.docker.com | sudo sh
sudo usermod -aG docker $USER # log out and back in after this
mkdir -p ~/n8n && cd ~/n8n
openssl rand -hex 32 # copy this; it becomes N8N_ENCRYPTION_KEY
```
~/n8n/.env
```bash
DOMAIN=n8n.example.com
N8N_ENCRYPTION_KEY=paste-the-random-string-here
GENERIC_TIMEZONE=Asia/Karachi
```
~/n8n/compose.yaml
```yaml
services:
n8n:
image: docker.n8n.io/n8nio/n8n:latest
restart: unless-stopped
environment:
- N8N_HOST=${DOMAIN}
- N8N_PROTOCOL=https
- N8N_PORT=5678
- WEBHOOK_URL=https://${DOMAIN}/
- N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
- GENERIC_TIMEZONE=${GENERIC_TIMEZONE}
- TZ=${GENERIC_TIMEZONE}
volumes:
- n8n_data:/home/node/.n8n
caddy:
image: caddy:2
restart: unless-stopped
ports:
- "80:80"
- "443:443"
environment:
- DOMAIN=${DOMAIN}
volumes:
- ./Caddyfile:/etc/caddy/Caddyfile:ro
- caddy_data:/data
volumes:
n8n_data:
caddy_data:
```
~/n8n/Caddyfile
```text
{$DOMAIN} {
reverse_proxy n8n:5678
}
```
Start it and watch the logs:
```bash
docker compose up -d
docker compose logs -f
```
> Notice that the n8n service publishes no ports. Caddy reaches it over the private Docker network, so the only way in is HTTPS through Caddy. That avoids the Docker-bypasses-UFW problem entirely.
## First login and the encryption key
Open `https://n8n.example.com` and create the owner account. Do it straight away: until an owner exists, whoever reaches the URL first can claim the instance.
n8n encrypts every saved credential with `N8N_ENCRYPTION_KEY`. Keep a copy somewhere safe, outside the server. If you lose it, restored backups can't decrypt your API keys and passwords, and every credential has to be re-entered.
## Updating n8n
n8n releases often. Read the release notes for breaking changes, take a backup, then pull and restart. Pin a specific version tag instead of `latest` if you'd rather update deliberately.
```bash
cd ~/n8n
docker compose pull
docker compose up -d
docker image prune -f
```
## Backups
Everything n8n stores (workflows, credentials, execution history in SQLite) lives in the `n8n_data` volume. Archive it on a schedule and copy the file off the server.
Archive the volume to the current folder:
```bash
docker run --rm \
-v n8n_n8n_data:/data:ro \
-v "$PWD":/backup \
alpine tar czf /backup/n8n-$(date +%F).tar.gz -C /data .
```
Or export workflows as JSON, which is handy for Git:
```bash
docker compose exec n8n n8n export:workflow --all --output=/home/node/.n8n/workflows.json
```
> Compose prefixes volume names with the folder name, so `n8n_data` in a folder called `n8n` becomes `n8n_n8n_data`. Check with `docker volume ls`.
- [Point a subdomain at your VPS](https://www.discountoffer.store/blog/point-domain-to-hostinger-vps)
- [Lock the server down first](https://www.discountoffer.store/blog/secure-hostinger-vps-checklist)
## FAQ
### Is self-hosted n8n free?
The Community Edition is free to self-host for internal use under n8n's Sustainable Use License. You pay only for the server. Some enterprise features need a paid licence.
### Can n8n run on KVM 1?
Yes. For personal and small-team automations, KVM 1's 4 GB of RAM is plenty. Move to KVM 2 when you add Postgres or run heavy file or AI workflows.
### Why do my webhooks show localhost URLs?
WEBHOOK_URL isn't set, or n8n was started before you set it. Set it to your public https URL with a trailing slash and recreate the container with `docker compose up -d`.
### Does the WEBHOST2026 coupon work on the VPS?
Yes. The links on this site apply WEBHOST2026 to VPS plans, and the 24 and 48-month terms have the lowest monthly price.
---
# Install Coolify on a Hostinger VPS: your own Vercel/Heroku for a flat price
URL: https://www.discountoffer.store/blog/install-coolify-on-hostinger-vps
Published: 2026-10-17 · Category: Tutorials
> Coolify gives you git push deploys, automatic HTTPS, databases and preview deploys on your own server. Install it on a Hostinger VPS, put the dashboard on your domain, deploy a first app and lock down the ports.
## What Coolify is, and when it's worth it
Coolify is an open-source platform you install on your own server. It gives you most of what Vercel, Netlify or Heroku do: connect a Git repo, push, and it builds and deploys with HTTPS. It also runs databases (Postgres, MySQL, Redis, MongoDB) and one-click services, and it can deploy a preview for each pull request.
It's worth it when you run several apps and want one dashboard for all of them. If you only have one app and you're happy with a deploy script, the plain setup in our Next.js and GitHub Actions guides is lighter.
## Which plan you need
Coolify needs at least 2 CPU cores and 2 GB of RAM to run itself, and builds happen on the same server. Builds are where memory runs out.
| Plan | Good for |
| --- | --- |
| KVM 1 (1 vCPU, 4 GB) | Below Coolify's 2-core minimum. It installs, but builds are slow. Fine for trying it out |
| KVM 2 (2 vCPU, 8 GB) | The sensible starting point: a handful of apps plus a database or two |
| KVM 4 (4 vCPU, 16 GB) | Many apps, frequent builds, or preview deploys for a team |
> To keep builds off production, add a second, cheaper server later and attach it in Coolify. One server builds and the other runs the apps, or you split apps across them.
## Option A — The Coolify template
Hostinger lists Coolify among its VPS OS templates. Choose it when you create the server, or reinstall an existing one from the VPS settings, and Coolify is installed for you on Ubuntu. Then skip to "First login" below.
> Reinstalling a VPS with a template wipes the disk. Take a snapshot first if anything on it matters.
## Option B — Install it yourself
Start from a fresh Ubuntu 24.04 server that you've secured (SSH keys, updates, a firewall). Coolify's installer sets up Docker and everything it needs. Run it as root or with sudo:
```bash
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash
```
> Run Coolify on a server dedicated to it. It manages Docker, the reverse proxy and ports 80/443 itself, which conflicts with an Nginx or Caddy you've already set up.
## First login
When the installer finishes, open `http://YOUR_SERVER_IP:8000` and create the admin account straight away. Until an account exists, whoever opens the URL first can claim the instance.
Coolify then asks where to deploy. Choose "This machine" (localhost) to run apps on the same server.
- Port 8000 is the dashboard until you give it a domain.
- Ports 6001 and 6002 carry the dashboard's realtime updates and the web terminal.
- Ports 80 and 443 belong to Coolify's proxy (Traefik), which serves your apps with HTTPS.
## Put the dashboard on your domain
Add an A record for a subdomain such as `coolify.example.com` pointing at the server, plus a wildcard `*.example.com` if you want Coolify to give every app its own subdomain automatically.
In Coolify, open Settings, enter `https://coolify.example.com` as the instance domain and save. The proxy requests a Let's Encrypt certificate, and the dashboard is now on HTTPS.
- [Adding A records, step by step](https://www.discountoffer.store/blog/point-domain-to-hostinger-vps)
## Deploy your first app
Using a GitHub repo as an example:
- Projects → Add → pick the environment (production) → New resource.
- Choose a public repository, or connect the Coolify GitHub App for private repos and automatic deploys on push.
- Pick the build pack. Nixpacks detects Node, Next.js, Laravel, Django and most common stacks. Choose Dockerfile or Docker Compose if your repo has one.
- Set the port your app listens on (3000 for Next.js), add environment variables, and set the domain, e.g. `https://app.example.com`.
- Click Deploy and watch the build log. Later pushes to the branch redeploy automatically.
> `NEXT_PUBLIC_*` and other build-time variables must be marked as available at build time in Coolify's environment settings, or they'll be undefined in the browser bundle.
## Lock down the ports
Coolify publishes ports through Docker, and Docker adds its own iptables rules that go around UFW. A UFW rule that blocks port 8000 won't actually block it. Use Hostinger's VPS firewall in hPanel instead, because it filters traffic before it reaches the server.
| Port | Keep open? |
| --- | --- |
| 22 (SSH) | Yes, ideally only from your IP |
| 80, 443 | Yes, for your apps and the dashboard |
| 8000 | Close once the dashboard is on your domain |
| 6001, 6002 | Close once the dashboard is on your domain; the proxy handles them from then on |
| Database ports (5432, 3306…) | Only if you made a database public on purpose; prefer keeping them internal |
- [The 10-minute VPS security checklist](https://www.discountoffer.store/blog/secure-hostinger-vps-checklist)
## Backups and updates
Coolify can back up the databases it manages on a schedule, to the server or to S3-compatible storage such as Cloudflare R2 or Backblaze B2. Set an S3 target, because a backup on the same server doesn't help if the server is lost. Hostinger's weekly VPS backups and snapshots are a second safety net for the whole disk.
Updates are one click in the dashboard, and you can turn on automatic updates. Read the release notes before updating a busy server, and take a snapshot first.
## FAQ
### Is Coolify free?
Yes. The self-hosted version is open source and free. You pay only for the server. Coolify also sells a hosted dashboard (Coolify Cloud) that manages your own servers for a fee.
### Can Coolify replace Vercel for Next.js?
For most apps, yes: Git deploys, HTTPS, environment variables and preview deploys all work. You lose Vercel's global edge network and its managed analytics, and you're responsible for the server.
### Can I run Coolify on KVM 1?
It installs, but KVM 1 has one CPU core and Coolify recommends at least two. It's fine for testing. For real apps, KVM 2 builds much faster.
### Why can I still reach port 8000 after blocking it in UFW?
Docker writes its own firewall rules that bypass UFW. Block the port in Hostinger's VPS firewall in hPanel, which sits in front of the server.
---
# Deploy Laravel on a Hostinger VPS (Nginx, PHP-FPM, MySQL, queues)
URL: https://www.discountoffer.store/blog/deploy-laravel-on-hostinger-vps
Published: 2026-10-17 · Category: Tutorials
> From a clean Ubuntu server to a production Laravel app: PHP-FPM, Composer, MySQL, the correct Nginx config, storage permissions, queue workers, the scheduler and free HTTPS.
## Shared hosting or VPS for Laravel?
A simple Laravel site can run on Hostinger's Premium or Business shared plans, which include SSH, Composer and a recent PHP version. You point the domain at the `public` folder and you're done.
Pick a VPS once you need queue workers that run all the time, Redis, WebSockets (Reverb), or full control over PHP extensions. That's the setup this guide covers.
## Before you start
You'll need the groundwork done first:
- Ubuntu 24.04 LTS on the VPS, secured with a sudo user and a firewall that allows 80 and 443.
- An A record for your domain pointing at the server.
- Your app in a Git repository the server can pull from.
- [The 10-minute VPS security checklist](https://www.discountoffer.store/blog/secure-hostinger-vps-checklist)
- [Point your domain to the VPS](https://www.discountoffer.store/blog/point-domain-to-hostinger-vps)
## Step 1 — Install PHP, Nginx, MySQL and Composer
Ubuntu 24.04 ships PHP 8.3, which meets the requirements of current Laravel releases. Check the `php` constraint in your `composer.json`. If you're on Ubuntu 26.04, swap `8.3` in the package names for whatever `php -v` reports.
```bash
sudo apt update
sudo apt install -y nginx mysql-server unzip git \
php8.3-fpm php8.3-cli php8.3-mysql php8.3-mbstring php8.3-xml \
php8.3-curl php8.3-zip php8.3-bcmath php8.3-intl php8.3-gd
sudo apt install -y composer
composer --version
```
## Step 2 — Create the database
Give the app its own MySQL user with access to one database, never root.
```bash
sudo mysql <<'SQL'
CREATE DATABASE laravel CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'laravel'@'localhost' IDENTIFIED BY 'use-a-long-random-password';
GRANT ALL PRIVILEGES ON laravel.* TO 'laravel'@'localhost';
FLUSH PRIVILEGES;
SQL
```
## Step 3 — Clone, install and configure
The deploy user owns the code. The web server's `www-data` group only needs write access to `storage` and `bootstrap/cache`, which is the cause of most 500 errors on a fresh Laravel server.
```bash
sudo mkdir -p /var/www && sudo chown $USER:$USER /var/www
cd /var/www
git clone https://github.com/you/your-app.git laravel
cd laravel
composer install --no-dev --optimize-autoloader
cp .env.example .env
php artisan key:generate
```
Edit .env: the lines that matter in production
```bash
APP_ENV=production
APP_DEBUG=false
APP_URL=https://example.com
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_DATABASE=laravel
DB_USERNAME=laravel
DB_PASSWORD=use-a-long-random-password
```
Permissions, migrations and caches:
```bash
sudo chown -R $USER:www-data storage bootstrap/cache
sudo chmod -R 775 storage bootstrap/cache
php artisan migrate --force
php artisan storage:link
php artisan optimize
```
> `APP_DEBUG=true` in production prints your environment variables, database password included, on every error page. Double-check it before you add the domain.
## Step 4 — Nginx server block
The document root must be `public`, not the project folder. Pointing Nginx at the project root exposes `.env` to anyone who asks for it.
/etc/nginx/sites-available/laravel
```nginx
server {
listen 80;
server_name example.com www.example.com;
root /var/www/laravel/public;
index index.php;
charset utf-8;
client_max_body_size 20M;
location / {
try_files $uri $uri/ /index.php?$query_string;
}
location = /favicon.ico { access_log off; log_not_found off; }
location = /robots.txt { access_log off; log_not_found off; }
error_page 404 /index.php;
location ~ ^/index\.php(/|$) {
fastcgi_pass unix:/run/php/php8.3-fpm.sock;
fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
include fastcgi_params;
fastcgi_hide_header X-Powered-By;
}
location ~ /\.(?!well-known).* {
deny all;
}
}
```
```bash
sudo ln -s /etc/nginx/sites-available/laravel /etc/nginx/sites-enabled/
sudo rm -f /etc/nginx/sites-enabled/default
sudo nginx -t && sudo systemctl reload nginx
```
## Step 5 — HTTPS
Same as any Nginx site: Certbot installs the certificate and renews it on a timer.
```bash
sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d example.com -d www.example.com
```
## Step 6 — Queue worker and scheduler
If your app dispatches jobs, something has to process them all the time. A systemd unit restarts the worker if it crashes and starts it on boot. The scheduler needs a single cron line.
/etc/systemd/system/laravel-worker.service
```ini
[Unit]
Description=Laravel queue worker
After=network.target mysql.service
[Service]
User=deploy
Group=www-data
WorkingDirectory=/var/www/laravel
ExecStart=/usr/bin/php artisan queue:work --sleep=3 --tries=3 --max-time=3600
Restart=always
RestartSec=5
[Install]
WantedBy=multi-user.target
```
```bash
sudo systemctl daemon-reload
sudo systemctl enable --now laravel-worker
# Scheduler: run 'crontab -e' as deploy and add
* * * * * cd /var/www/laravel && php artisan schedule:run >> /dev/null 2>&1
```
> Replace `deploy` with your own username. Workers keep the old code in memory, so the deploy script below restarts them on every release.
## Step 7 — A redeploy script
Save it as `deploy.sh` in the project and it works with our GitHub Actions guide unchanged.
```bash
#!/usr/bin/env bash
set -euo pipefail
cd /var/www/laravel
php artisan down --retry=15 || true
git pull origin main
composer install --no-dev --optimize-autoloader --no-interaction
php artisan migrate --force
php artisan optimize
sudo systemctl restart laravel-worker
sudo systemctl reload php8.3-fpm
php artisan up
echo "Deployed at $(date -Iseconds)"
```
> To run those two `systemctl` commands without a password prompt from CI, add a sudoers rule limited to exactly those commands with `sudo visudo -f /etc/sudoers.d/deploy`.
- [Push-to-deploy with GitHub Actions](https://www.discountoffer.store/blog/github-actions-deploy-to-hostinger-vps)
## FAQ
### Can I host Laravel on Hostinger shared hosting?
Yes, on plans with SSH access (Premium and up). Upload the project, run Composer over SSH, and set the domain's document root to the public folder. Long-running queue workers and Redis need a VPS.
### Which Hostinger VPS plan is enough for Laravel?
KVM 1 runs a typical Laravel app with MySQL and a queue worker comfortably. Move to KVM 2 when you add Redis, Horizon with several queues, or noticeably more traffic.
### Why do I get a 500 error after deploying?
Almost always permissions on storage or bootstrap/cache, or a missing APP_KEY. Check storage/logs/laravel.log, and run the chown and chmod commands from Step 3 again.
### Should I use Forge or a control panel instead?
If you'd rather not manage servers by hand, Laravel Forge or a panel like CloudPanel provisions everything in this guide for you, on the same Hostinger VPS.
---
# Deploy Django on a Hostinger VPS (Gunicorn, Nginx, PostgreSQL)
URL: https://www.discountoffer.store/blog/deploy-django-on-hostinger-vps
Published: 2026-10-17 · Category: Tutorials
> A production Django setup on Ubuntu: a virtualenv, PostgreSQL, Gunicorn under systemd, Nginx serving static files, the security settings Django needs behind a proxy, and free HTTPS.
## What you'll end up with
Nginx takes the request, serves static and media files straight from disk, and passes everything else over a Unix socket to Gunicorn, which runs your Django app. systemd keeps Gunicorn alive. PostgreSQL holds the data on the same machine.
This assumes Ubuntu 24.04 with a secured sudo user and an A record already pointing at the server.
- [Secure the VPS first](https://www.discountoffer.store/blog/secure-hostinger-vps-checklist)
- [Point your domain to the VPS](https://www.discountoffer.store/blog/point-domain-to-hostinger-vps)
## Step 1 — System packages and the database
Ubuntu 24.04's Python 3.12 is supported by current Django releases.
```bash
sudo apt update
sudo apt install -y python3-venv python3-dev build-essential libpq-dev \
postgresql nginx git
```
Create a database and a user that owns it:
```bash
sudo -u postgres psql <<'SQL'
CREATE USER myproject WITH PASSWORD 'use-a-long-random-password';
CREATE DATABASE myproject OWNER myproject;
SQL
```
## Step 2 — Code and virtualenv
```bash
sudo mkdir -p /var/www && sudo chown $USER:$USER /var/www
cd /var/www
git clone https://github.com/you/myproject.git
cd myproject
python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt gunicorn "psycopg[binary]"
```
## Step 3 — Production settings
Read secrets from the environment, not from `settings.py`. The proxy settings matter: without them Django thinks every request arrived over plain HTTP, and secure cookies and CSRF checks break.
settings.py (the production-relevant parts)
```python
import os
SECRET_KEY = os.environ["DJANGO_SECRET_KEY"]
DEBUG = False
ALLOWED_HOSTS = ["example.com", "www.example.com"]
CSRF_TRUSTED_ORIGINS = ["https://example.com", "https://www.example.com"]
DATABASES = {
"default": {
"ENGINE": "django.db.backends.postgresql",
"NAME": "myproject",
"USER": "myproject",
"PASSWORD": os.environ["DB_PASSWORD"],
"HOST": "127.0.0.1",
"PORT": "5432",
}
}
STATIC_URL = "static/"
STATIC_ROOT = BASE_DIR / "staticfiles"
MEDIA_URL = "media/"
MEDIA_ROOT = BASE_DIR / "media"
# Behind Nginx terminating HTTPS
SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
```
/var/www/myproject/.env (chmod 600)
```bash
DJANGO_SECRET_KEY=generate-a-long-random-string
DB_PASSWORD=use-a-long-random-password
```
Migrate and collect static files:
```bash
set -a; source .env; set +a
python manage.py migrate
python manage.py collectstatic --noinput
python manage.py createsuperuser
python manage.py check --deploy
```
> `manage.py check --deploy` lists every security setting you've missed. Run it before going live and fix what it reports.
## Step 4 — Gunicorn under systemd
A common starting point for workers is two per CPU core plus one, so 3 on KVM 1 and 5 on KVM 2. `RuntimeDirectory` makes systemd create `/run/gunicorn` for the socket on every start.
/etc/systemd/system/gunicorn.service
```ini
[Unit]
Description=Gunicorn for myproject
After=network.target postgresql.service
[Service]
User=deploy
Group=www-data
WorkingDirectory=/var/www/myproject
EnvironmentFile=/var/www/myproject/.env
RuntimeDirectory=gunicorn
ExecStart=/var/www/myproject/.venv/bin/gunicorn \
--workers 3 \
--bind unix:/run/gunicorn/myproject.sock \
--access-logfile - \
myproject.wsgi:application
Restart=always
[Install]
WantedBy=multi-user.target
```
```bash
sudo systemctl daemon-reload
sudo systemctl enable --now gunicorn
sudo systemctl status gunicorn
journalctl -u gunicorn -f # live logs
```
## Step 5 — Nginx
Static and media files never touch Python; Nginx serves them directly.
/etc/nginx/sites-available/myproject
```nginx
server {
listen 80;
server_name example.com www.example.com;
client_max_body_size 20M;
location /static/ {
alias /var/www/myproject/staticfiles/;
expires 30d;
}
location /media/ {
alias /var/www/myproject/media/;
}
location / {
proxy_pass http://unix:/run/gunicorn/myproject.sock;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
```
```bash
sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled/
sudo rm -f /etc/nginx/sites-enabled/default
sudo nginx -t && sudo systemctl reload nginx
sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d example.com -d www.example.com
```
> Getting a 403 on static files? Nginx runs as www-data and needs execute permission on every folder down the path. `chmod o+x` on /var/www and the project folder usually fixes it.
## Redeploying
The same pattern as every other guide here: a script that GitHub Actions can call.
/var/www/myproject/deploy.sh
```bash
#!/usr/bin/env bash
set -euo pipefail
cd /var/www/myproject
set -a; source .env; set +a
git pull origin main
.venv/bin/pip install -r requirements.txt
.venv/bin/python manage.py migrate --noinput
.venv/bin/python manage.py collectstatic --noinput
sudo systemctl restart gunicorn
echo "Deployed at $(date -Iseconds)"
```
- [Trigger this on every push with GitHub Actions](https://www.discountoffer.store/blog/github-actions-deploy-to-hostinger-vps)
## FAQ
### Can I run Django on Hostinger shared hosting?
Not well. Shared plans are built for PHP and don't let you run a long-lived Python process like Gunicorn. Use a VPS for Django.
### Which VPS plan do I need for Django?
KVM 1 handles a typical Django app with PostgreSQL. Choose KVM 2 if you add Celery workers and Redis, or expect steady traffic.
### Why does Django say 'Bad Request (400)'?
The domain isn't in ALLOWED_HOSTS. Add every hostname you serve, including www, and restart Gunicorn.
### Where do I see errors when DEBUG is off?
Run `journalctl -u gunicorn` for app errors and check /var/log/nginx/error.log for proxy errors. Setting up ADMINS with email, or an error tracker such as Sentry, saves a lot of digging.
---
# Deploy a React (Vite) app on Hostinger shared hosting
URL: https://www.discountoffer.store/blog/deploy-react-vite-app-on-hostinger
Published: 2026-10-17 · Category: Tutorials
> No VPS needed: build your React app, upload it with hPanel's File Manager or FTP, fix the 404-on-refresh problem with one .htaccess file, and add caching and HTTPS.
## When shared hosting is enough
A React app built with Vite is just HTML, JavaScript and CSS once it's built. There's no server code to run, so any Hostinger web hosting plan can serve it, and you can skip the VPS entirely.
The same steps work for Vue, Svelte, Astro, plain HTML and Next.js with `output: 'export'`. If your app needs server rendering, API routes or a database, you need a VPS or a plan with managed Node.js instead.
- [Need SSR? Deploy Next.js on a VPS](https://www.discountoffer.store/blog/deploy-nextjs-app-on-hostinger-vps)
## Step 1 — Build
Environment variables prefixed with `VITE_` are baked into the bundle at build time. Set production values before building, and never put secrets in them; anyone can read them in the browser.
```bash
npm ci
npm run build
# Output is in ./dist
```
## Step 2 — Add the .htaccess before you upload
With React Router, a link like `/dashboard` works when you click it but returns a 404 when you refresh, because the server looks for a real `/dashboard` file. This rule sends every unknown path to `index.html` so the router can handle it.
Put the file in your project's `public` folder. Vite copies everything in `public` into `dist`, so it's included in every build automatically.
public/.htaccess
```apache
RewriteEngine On
RewriteBase /
# Force HTTPS
RewriteCond %{HTTPS} !=on
RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]
# Send unknown paths to the SPA
RewriteRule ^index\.html$ - [L]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /index.html [L]
# Vite's hashed assets never change, so cache them for a year
Header set Cache-Control "public, max-age=31536000, immutable"
Header set Cache-Control "no-cache"
```
> Files starting with a dot are hidden on macOS and Linux, so they're easy to miss when you zip or upload. Check that .htaccess is actually inside dist after the build.
## Step 3 — Upload to public_html
Upload the contents of `dist`, not the `dist` folder itself. `index.html` must sit directly inside `public_html`.
- File Manager: zip the contents of dist, open hPanel → Files → File Manager → public_html, upload the zip, then right-click and extract. Delete the default index.php or default.php if there is one.
- FTP: create an FTP account in hPanel, connect with FileZilla, and drag the contents of dist into public_html.
- Automated: have GitHub Actions build the app and upload dist over FTP on every push, so you never upload by hand.
## Deploying to a subfolder
If the app lives at `example.com/app/` rather than the root, tell Vite and the router about the base path, and adjust the .htaccess to match.
vite.config.ts
```ts
import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
export default defineConfig({
plugins: [react()],
base: "/app/",
});
```
React Router
```tsx
```
> In the subfolder's .htaccess, change `RewriteBase /` to `RewriteBase /app/` and the last rule to `RewriteRule . /app/index.html [L]`.
## Step 4 — HTTPS and a quick check
Hostinger includes a free SSL certificate on web hosting plans. Make sure it's active under the website's Security → SSL section in hPanel; it's usually installed automatically within a few minutes of adding the domain.
Then open the site, click into a nested route and refresh. If you get the page and not a 404, the rewrite is working.
## FAQ
### Which Hostinger plan should I use for a React app?
For one app, Single or Premium web hosting is plenty, since it only serves static files. Premium lets you host more sites and includes a free domain on longer terms.
### Why is my page blank after uploading?
Usually the asset paths are wrong. If the app isn't at the domain root, set `base` in vite.config.ts. Open the browser console: 404s on /assets/... files confirm it.
### Can I host a React frontend on shared hosting with a Node backend?
The frontend, yes. The Node API needs a VPS or a plan with managed Node.js. A common setup is the React build on web hosting and the API on a small VPS at api.example.com.
### Does WEBHOST2026 work on web hosting?
Yes. The links on this site apply WEBHOST2026 to web hosting plans for an extra 20% off eligible terms.
---
# Hostinger VPS vs Hetzner vs Contabo (2026): the cheap VPS showdown
URL: https://www.discountoffer.store/blog/hostinger-vps-vs-hetzner-vs-contabo
Published: 2026-10-17 · Category: Comparisons
> Three budget VPS providers developers keep shortlisting, compared on what you actually get: RAM per dollar, CPU consistency, locations, billing model, backups and the renewal catch. Who should pick which.
## The short answer
Pick Hetzner if you want the best price-to-performance with no promotional pricing, and your users are near Europe or the US. Pick Contabo if you need the most RAM and disk for the money, and can live with slower, less predictable CPU. Pick Hostinger if you want a lot of RAM at a low prepaid price, more server locations including Asia and South America, and a dashboard with one-click templates and backups included.
For a typical side project or small production app (Next.js, a Node API, n8n, a couple of Docker containers), Hostinger's KVM 1 at $4.99/mo on 48 months is the easiest good choice, especially with WEBHOST2026 taking an extra 20% off.
## How they differ at a glance
Competitor prices change often and differ by country, so we don't quote them. Open each host's pricing page on the same day and compare the 12, 24 or 36-month intro price and the renewal price side by side.
| | Hostinger VPS | Hetzner Cloud | Contabo VPS |
| --- | --- | --- | --- |
| Pricing model | Prepaid 12, 24 or 48 months at a promo price; renews higher | Hourly, capped at a monthly price; no promo, no renewal jump | Monthly or longer terms; longer terms can remove setup fees |
| Entry RAM | 4 GB on KVM 1 | Small on the cheapest shared-vCPU plans; more on the next tiers | Large for the price, a main selling point |
| CPU | Dedicated KVM resources on AMD EPYC | Shared or dedicated vCPU lines, Intel, AMD and Arm | Shared; performance can vary under load |
| Storage | NVMe | NVMe on most lines, plus block volumes | NVMe or SSD; large-disk options |
| Locations | Europe, US, Asia, South America and more | Germany, Finland, US and Singapore | Europe, US, Asia, Australia and more |
| Backups | Weekly backups and snapshots included | Paid add-on (a percentage of the server price) | Snapshots included; automated backups are an add-on |
| Dashboard | hPanel with 100+ OS/app templates, browser terminal, AI assistant | Clean cloud console and a strong API/CLI | Basic customer panel |
| Walking away | 30-day money-back, then committed for the term | Delete the server, billing stops within the hour | Notice periods apply; check the terms |
## Hostinger: most machine for a prepaid price
Hostinger's selling point is RAM. KVM 1 gives 1 vCPU, 4 GB RAM and 50 GB NVMe, and KVM 2 doubles that (2 vCPU, 8 GB, 100 GB) for $6.99/mo on 48 months. That's enough to build Next.js on the server, run Postgres beside the app, or host several small projects on one box.
It's also the friendliest of the three for people who don't live in a terminal: one-click templates for Docker, n8n, Coolify and control panels, weekly backups included, and a browser terminal for the day SSH breaks.
The catch is the billing model. You prepay the term, and renewal is noticeably higher than the promo price. The value is best when you commit to a long term and stay for it.
- [Hostinger VPS for developers: the honest review](https://www.discountoffer.store/blog/hostinger-vps-for-developers-honest-review)
## Hetzner: honest pricing, strong performance
Hetzner is the developer favourite in Europe for good reason. Prices are low without promotions, billing is hourly, and the price you sign up at is the price you keep. Performance is consistent, and the API, CLI and Terraform provider are excellent if you automate infrastructure.
The trade-offs: fewer regions (nothing in South Asia, the Middle East or South America), backups cost extra, and new accounts sometimes need ID verification before they can create servers. Some sign-ups are rejected outright, especially from countries Hetzner considers high-risk for fraud.
## Contabo: huge specs, variable speed
Contabo has a reputation for the biggest RAM and disk numbers per dollar in the market, and on paper it's unmatched. That makes it popular for workloads that need memory or storage more than CPU, like game servers, backups or large databases that are rarely queried.
The criticism is just as well known. CPU performance is shared and can vary a lot between servers and times of day. Provisioning and support are slower than the other two, and there may be setup fees on short terms. Benchmark your own server in the first days before you depend on it.
## Which one for which project
- A Next.js, Node or Laravel app you'll run for years → Hostinger on a long term. 4–8 GB RAM covers builds and a database, with backups included.
- Infrastructure-as-code, autoscaling experiments, short-lived servers → Hetzner. Hourly billing and the API win.
- You need lots of RAM or disk and CPU speed isn't critical → Contabo, after benchmarking.
- Your users are in Pakistan, India, the Middle East or Southeast Asia → Hostinger or Contabo, which both have nearby Asian locations. Hetzner's only Asian region is Singapore.
- You might cancel within three months → Hetzner. Prepaid terms only pay off if you stay.
- You'd rather click than type → Hostinger. Its templates and panel take a lot of the server administration off your hands.
> Full disclosure: this site earns a referral commission on Hostinger. That's why the renewal catch is spelled out above. If Hetzner or Contabo fits your project better, use them.
## Getting the lowest Hostinger VPS price
The 48-month term has the lowest monthly price, and WEBHOST2026 takes an extra 20% off on top: KVM 1 comes to about $3.99/mo and KVM 2 to about $5.59/mo. The links on this site add the code for you.
- [Hostinger VPS coupon: plans and prices](https://www.discountoffer.store/blog/hostinger-vps-coupon-code)
- [Hostinger VPS vs a DigitalOcean droplet](https://www.discountoffer.store/blog/hostinger-vps-vs-digitalocean-droplet)
## FAQ
### Is Hostinger VPS better than Hetzner?
For RAM per dollar on a long prepaid term, more locations and included backups, yes. For hourly billing, flat long-term pricing and an infrastructure API, Hetzner is better. It depends on how long you'll keep the server.
### Why is Contabo so cheap?
It sells large RAM and disk allocations on shared CPU, and puts less into fast provisioning and support. The specs are real, but CPU performance can vary, so benchmark before relying on it.
### Which cheap VPS is best for Pakistan or India?
Pick a provider with a nearby Asian location. Hostinger and Contabo both have locations in Asia, and Hostinger also bills in local currency with local payment methods in both countries.
### Does WEBHOST2026 work on Hostinger VPS plans?
Yes. It adds an extra 20% off KVM plans on top of the sale price, on 12, 24 and 48-month terms.
---
# Hostinger refund policy: how the 30-day money-back guarantee works
URL: https://www.discountoffer.store/blog/hostinger-refund-policy-30-day-money-back
Published: 2026-10-17 · Category: Guides
> What Hostinger refunds within 30 days, what it never refunds (domains are the big one), how the free domain changes your refund, and how to request it step by step.
## The short version
Hostinger gives a full refund on most hosting plans if you cancel within 30 days of buying them. That covers web, WordPress, cloud and VPS hosting and the Website Builder. You don't have to give a reason.
The exceptions matter more than the rule. Domain registrations aren't refundable. If your plan came with a free domain and you claimed it, expect its cost to come out of the refund. After day 30, hosting isn't refunded at all.
## What's refundable and what isn't
How the guarantee applies to the things people usually buy:
| Item | Refundable within 30 days? | Notes |
| --- | --- | --- |
| Web, WordPress and cloud hosting | Yes | Full amount for the term you prepaid, including multi-year terms |
| VPS hosting | Yes | Same 30-day window as shared hosting |
| Website Builder | Yes | Treated like a hosting plan |
| Domain registration or transfer | No | The domain stays yours until it expires |
| Free domain included with a plan | Partly | If you claimed it, its value is usually deducted from the hosting refund |
| Add-ons (email, SSL, privacy) | Depends | Check the cancellation screen; some add-ons follow the hosting, some don't |
> The refund goes back to the payment method you used. A few methods can't receive refunds automatically, so Hostinger may arrange it another way. The cancellation screen and support chat tell you which applies to your order.
## Why the 30 days start at purchase, not at setup
The clock starts when you pay, not when you install WordPress or point your domain. If you buy now and only start building in three weeks, you have about one week to decide.
So test early. Install the site or log in to the VPS on the first day, run whatever you need to check (speed, email delivery, your app's build), and decide while the guarantee still applies.
## How to request a refund
It takes a few minutes in hPanel:
- Log in to hPanel and open Billing, then Subscriptions.
- Find the plan you want refunded and open its settings.
- Choose the option to cancel the subscription. Inside the 30 days, hPanel offers an immediate cancellation with a refund.
- Pick a reason (any reason is fine), check the refund amount it shows, and confirm.
- If you don't see a refund option, open live chat from hPanel and ask for a refund under the 30-day money-back guarantee. Support can process it for you.
> Immediate cancellation deletes the website files, databases and mailboxes on that plan. Download a backup first if you might want anything from it.
- [Step-by-step: cancel a Hostinger plan without losing your domain](https://www.discountoffer.store/blog/how-to-cancel-hostinger)
## How long the refund takes
Hostinger approves the refund on its side quickly, often the same day. How long it takes to reach you depends on your payment provider. Cards usually take 5–10 business days to show the credit, and wallets are often faster.
If the money hasn't arrived after two weeks, ask support for the refund reference and give it to your bank or wallet provider.
## Refunds and renewals
The 30-day guarantee is for new purchases. Don't count on it for a renewal you forgot to stop. The reliable fix is to turn off auto-renewal as soon as you know you won't keep a plan. It stays active until the end of the term you paid for.
- [How to pay less when your plan renews](https://www.discountoffer.store/blog/hostinger-renewal-price-how-to-pay-less)
## Does using a coupon affect the refund?
No. With WEBHOST2026 you're refunded what you actually paid, so the discounted total, minus anything non-refundable such as a claimed domain. The coupon doesn't shorten the 30 days or exclude any plan from the guarantee.
Because the guarantee makes trying Hostinger low-risk, the long terms with the lowest monthly price aren't as big a commitment as they look.
## FAQ
### Does Hostinger really refund within 30 days?
Yes, for hosting plans. Cancel within 30 days of purchase and the hosting part is refunded in full. Domain registrations, and the value of a claimed free domain, aren't included.
### Can I get a refund on a 48-month plan?
Yes, within the first 30 days. The guarantee covers the whole prepaid amount for the hosting, whatever term you picked.
### Will I lose my domain if I get a refund?
No. The domain registration is separate and stays yours until it expires. You can keep it at Hostinger or transfer it once the registrar's transfer lock ends.
### Can I get a refund after 30 days?
Not for hosting under the standard guarantee. You can still turn off auto-renewal so you're not charged again.
---
# How to cancel Hostinger (and keep your domain and files)
URL: https://www.discountoffer.store/blog/how-to-cancel-hostinger
Published: 2026-10-17 · Category: Guides
> Turn off auto-renewal, cancel a plan immediately, or close the whole account, step by step in hPanel. Plus what happens to your domain, email and website files, and what to back up first.
## Pick the right kind of cancellation
"Cancel" covers three different things at Hostinger, and choosing the wrong one is how people lose a website they meant to keep for a few more months.
| What you do | What happens | Choose it when |
| --- | --- | --- |
| Turn off auto-renewal | The plan runs until the paid term ends, then expires | You've paid for the term and just don't want to renew |
| Cancel immediately | The plan stops now and its data is deleted; a refund applies within 30 days | You're inside the 30-day guarantee and want your money back |
| Close the account | Everything on the account is removed | You've moved everything elsewhere, domains included |
## Before you cancel: back up three things
Immediate cancellation deletes the plan's data. Even when you only turn off auto-renewal, the data goes when the plan expires. Save these first:
- Website files and databases. In hPanel, open the website, go to Files → Backups and download the latest file and database backup. On WordPress, a plugin export works too.
- Email. Mailboxes on the plan are deleted with it. Export them through an email client (IMAP), or move them to the new provider first.
- VPS data. Take a snapshot for safety, but snapshots live on Hostinger and go with the server. Copy anything you need off the machine with rsync or scp.
## Option 1 — Turn off auto-renewal
The safest choice if you've already paid for the term:
- Log in to hPanel and open Billing → Subscriptions.
- Find the plan and switch auto-renewal off (in the plan's settings or the auto-renewal toggle).
- Confirm. The plan stays fully working until its expiry date, and you won't be charged again.
> Do the same for the domain if you don't want it to renew. Hosting and domains are separate subscriptions, so turning off one doesn't turn off the other.
## Option 2 — Cancel immediately (and get a refund)
In Billing → Subscriptions, open the plan's settings and choose the option to cancel the subscription now. Inside the first 30 days this includes a refund for the hosting. hPanel shows the amount before you confirm.
If the option isn't there, ask support in live chat to cancel the plan and process the refund. Chat is in hPanel, available 24/7.
- [What the 30-day refund covers (and what it doesn't)](https://www.discountoffer.store/blog/hostinger-refund-policy-30-day-money-back)
## Option 3 — Close the whole account
There's no self-service "delete account" button for every case. Cancel or expire every subscription first, move your domains out, then ask support in chat to close the account and delete your personal data.
## What happens to your domain
Cancelling hosting doesn't cancel a domain registration. The domain stays yours until its expiry date, including the free domain that came with your plan, and it keeps whatever DNS records it has.
To keep the domain long term, either renew it at Hostinger or transfer it to another registrar. Get the transfer (EPP) code from the domain's settings in hPanel and unlock the domain. New registrations and recent transfers have a 60-day lock, so you may need to wait before transferring.
> If the free domain came with your plan, it renews at the normal domain price after the first year. Turn off its auto-renewal separately if you don't want it.
- [How Hostinger's free domain works](https://www.discountoffer.store/blog/hostinger-free-domain-how-to-claim)
## Cancelling because of the renewal price?
That's the most common reason, and there's often a cheaper fix than moving hosts. Buying a new long-term plan on a promotional price can cost less than renewing, and moving the site across takes minutes with Hostinger's migration tool.
If you go that way, WEBHOST2026 applies to the new plan through the links on this site.
- [How to pay less at renewal](https://www.discountoffer.store/blog/hostinger-renewal-price-how-to-pay-less)
## FAQ
### Does Hostinger charge a cancellation fee?
No. Turning off auto-renewal or cancelling a plan is free. Within 30 days you get the hosting refunded; after that you simply aren't charged again.
### If I cancel, does my website go offline right away?
Only with immediate cancellation. If you just turn off auto-renewal, the site keeps running until the end of the term you paid for.
### Can I cancel Hostinger and keep my domain?
Yes. The domain is a separate subscription and stays yours until it expires. Renew it or transfer it to another registrar when you're ready.
### How do I stop Hostinger charging my card?
Turn off auto-renewal for every subscription (hosting, domain, email) in Billing → Subscriptions. You can also remove the saved card in the payment methods section.
---
# Pay for Hostinger with a debit card in Pakistan (and fix a declined card)
URL: https://www.discountoffer.store/blog/pay-hostinger-with-debit-card-pakistan
Published: 2026-10-17 · Category: Guides
> Use a Pakistani bank debit card or a digital-bank card to buy Hostinger in rupees. What to switch on in your banking app first, why cards get declined, and what to do about Easypaisa.
## Which cards work
Hostinger's Pakistan store (hostinger.com/pk) takes Visa and Mastercard debit and credit cards, as well as JazzCash and crypto. Almost any Pakistani card works once online payments are switched on:
- Bank debit cards: the Visa or Mastercard debit card from your bank account (HBL, Meezan, UBL, MCB, Bank Alfalah and so on). PayPak-only cards usually won't work online abroad, so check that your card has a Visa or Mastercard logo.
- Digital-bank and wallet cards: virtual or physical Visa/Mastercard cards from apps like SadaPay or NayaPay generally work for online payments, within the app's limits.
- Credit cards: work with no extra setup on most banks.
> Easypaisa isn't on Hostinger's payment list for Pakistan. If you have an Easypaisa debit card linked to your account, pay with it as a card, or use JazzCash.
## Before you pay: switch on online payments
Most declined cards in Pakistan have nothing to do with Hostinger. The card just isn't allowed to pay online or abroad yet. Do this in your banking app first:
- Turn on e-commerce / online transactions for the card.
- Turn on international transactions as well. Hostinger is a foreign merchant even when the price shows in rupees.
- Check the daily online limit covers the full upfront amount, not one month's price.
- Make sure you can receive the OTP. Bank OTPs go to the mobile number registered with the bank.
## You pay the whole term upfront
The monthly price is for comparison. The card is charged the full term at once, so the balance and limit need to cover this amount:
| Plan | Promo / month | Term | Charged upfront (before coupon and tax) |
| --- | --- | --- | --- |
| Single | Rs 399 | 48 months | Rs 19,152 |
| Premium | Rs 599 | 48 months | Rs 28,752 |
| KVM 1 VPS | Rs 2,099 | 24 months | Rs 50,376 |
> WEBHOST2026 takes an extra 20% off these totals on eligible plans. If the full amount is too much for your limit, a shorter term costs more per month but less upfront.
## Step by step
- Open Hostinger through a link on this site. It opens hostinger.com/pk with WEBHOST2026 applied, so prices show in rupees.
- Pick the plan and term, then create your account.
- On the payment step, choose card. Check that the order summary shows WEBHOST2026 and a discount line.
- Enter the card number, expiry and CVV, then approve the OTP or the prompt in your banking app (3-D Secure).
- You'll land in hPanel when the payment succeeds, and the invoice arrives by email.
## If your card is declined
Work down this list. The first two cover most cases:
| What you see | Likely cause and fix |
| --- | --- |
| Declined straight away, no OTP | Online or international payments are off. Turn them on in the banking app and retry. |
| Declined after the OTP | Not enough balance, or the daily online limit is lower than the upfront total. Top up or raise the limit. |
| OTP never arrives | The bank has an old mobile number on file, or SMS is delayed. Use the app's approval prompt if it has one, or update the number at the bank. |
| Payment page keeps failing | Try another browser without ad blockers or VPN. A VPN can also put you on a different country store. |
| Still declined | Call the bank's helpline. They can see the reason code and whitelist the payment. Or pay with JazzCash instead. |
- [Paying with JazzCash instead](https://www.discountoffer.store/blog/buy-hostinger-in-pakistan-with-jazzcash)
## Will the bank add extra charges?
On the /pk store you're charged in rupees, so there's normally no currency conversion. Some banks still treat it as a foreign online transaction and add their own fee or tax. Your bank's schedule of charges lists them, and the statement shows the exact amount.
If your card is ever charged in dollars, you're on the wrong store. Reopen Hostinger through a link on this site to get the rupee checkout.
## Renewals and saved cards
Hostinger saves the card for auto-renewal. If you'd rather pay renewals by hand, turn auto-renewal off in hPanel under Billing → Subscriptions. You can renew manually with a card or JazzCash before the plan expires.
## FAQ
### Can I pay Hostinger with a Pakistani debit card?
Yes. Visa and Mastercard debit cards from Pakistani banks work on hostinger.com/pk once online and international transactions are switched on in your banking app.
### Does SadaPay or NayaPay work with Hostinger?
Their Visa/Mastercard cards generally work like any other debit card for online payments, as long as the balance and the app's limits cover the full upfront amount.
### Can I pay Hostinger with Easypaisa?
Easypaisa isn't on Hostinger's official payment list for Pakistan. Use an Easypaisa-linked debit card as a card payment if you have one, or pay with JazzCash.
### Why was I charged in dollars?
You bought from a non-Pakistan Hostinger store. Use hostinger.com/pk (our links open it) to pay in rupees with no currency conversion.
---
# Hostinger vs Bluehost (2026): which is better for your website?
URL: https://www.discountoffer.store/blog/hostinger-vs-bluehost
Published: 2026-10-16 · Category: Comparisons
> Two of the most popular cheap hosts, compared on speed, features, dashboard, support and the real long-term cost. Who should pick which, in plain English.
## The short answer
Pick Hostinger if you want the lowest price for good speed, a modern dashboard and servers outside the US as well as inside it. Pick Bluehost if you specifically want a long-established US host, and you're happy to pay more over time for it.
For most new WordPress sites, Hostinger is the better value, especially with WEBHOST2026 taking an extra 20% off.
## Who they are
Hostinger was founded in 2004 in Lithuania and now runs data centers across North America, Europe, Asia and South America. It built its own control panel, hPanel.
Bluehost is a US host founded in 2003 and is part of Newfold Digital, which also owns several other hosting brands. It's been listed for many years as a recommended host on WordPress.org.
## Side by side
How the two compare on the things that matter most for a typical site:
| | Hostinger | Bluehost |
| --- | --- | --- |
| Entry price (intro) | From $2.49/mo on Premium, 48 months | Check their site (changes often) |
| With an extra 20% coupon | About $1.99/mo | Varies by promotion |
| Data centers | US, Europe, Asia, South America | Mainly US |
| Dashboard | hPanel (custom) | Bluehost dashboard (custom) |
| Free domain | First year on Premium and up | First year on most plans |
| Support | 24/7 live chat and tickets | 24/7 chat and phone |
| Money-back | 30 days | 30 days |
> Competitor prices change often and differ by country, so we don't quote them. Open each host's pricing page on the same day and compare the 12, 24 or 36-month intro price and the renewal price side by side.
## Speed
Hostinger's LiteSpeed servers and the LiteSpeed Cache plugin give WordPress fast page loads with almost no setup, and the built-in CDN helps visitors far from your server. You can also put the site in the data center nearest your audience, which matters if they aren't in the US.
Bluehost is perfectly fast enough for most small sites, especially for US visitors. If your audience is in Europe or Asia, Hostinger's wider choice of locations is a real advantage.
## Ease of use
Both are beginner-friendly and both install WordPress for you. hPanel is clean and puts everything (sites, domains, email, backups) on one screen. Bluehost's dashboard is also simple and leans heavily on WordPress-first setup.
## Support
Bluehost offers phone support, which some people strongly prefer. Hostinger is chat and ticket only, but the chat is 24/7, and its AI assistant, Kodee, answers many setup questions instantly. If you need to talk to someone on the phone, that's a point for Bluehost.
## The real cost: renewals
Both hosts sell a low introductory price and renew at a higher standard rate. The most useful thing you can do is compare the total for the whole period you'll stay, intro term plus at least one renewal. Hostinger's 48-month term keeps the intro price longest.
- [How Hostinger renewals work and how to pay less](https://www.discountoffer.store/blog/hostinger-renewal-price-how-to-pay-less)
## Verdict
- Choose Hostinger for the lowest price, LiteSpeed speed, and servers near a non-US audience.
- Choose Bluehost if you want phone support and a long-standing US-only company.
- Moving later is easy either way: WordPress sites migrate in under an hour.
## FAQ
### Is Hostinger cheaper than Bluehost?
On the intro term, usually yes, and WEBHOST2026 takes an extra 20% off Hostinger. Always compare renewal prices too.
### Is Hostinger or Bluehost better for WordPress?
Both run WordPress well. Hostinger tends to be faster out of the box thanks to LiteSpeed caching; Bluehost has a long WordPress.org recommendation history.
### Can I move from Bluehost to Hostinger?
Yes. Hostinger's free migration tool copies a WordPress site across, and your Bluehost site stays live until you change DNS.
---
# Hostinger vs GoDaddy (2026): hosting, domains and real cost
URL: https://www.discountoffer.store/blog/hostinger-vs-godaddy
Published: 2026-10-16 · Category: Comparisons
> GoDaddy is the domain giant; Hostinger is the budget hosting specialist. How they compare for a website, where each one wins, and why many people buy the domain at one and host at the other.
## The short answer
For hosting a website, Hostinger is usually faster per dollar and simpler to use. GoDaddy's strength is domains: it's the world's largest domain registrar, with a huge range of extensions and a well-known brand.
You don't have to choose one for everything. Plenty of people keep a domain at GoDaddy and point it at Hostinger hosting.
## Side by side
| | Hostinger | GoDaddy |
| --- | --- | --- |
| Best known for | Low-cost, fast hosting | Domain registration |
| Entry hosting price | From $2.49/mo (48 mo) | Check their site (changes often) |
| With an extra 20% coupon | About $1.99/mo | Varies by promotion |
| Control panel | hPanel (custom) | cPanel on many plans |
| Free domain | First year on Premium and up | First year on annual plans |
| Support | 24/7 chat and tickets | Chat and phone |
> Competitor prices change often and differ by country, so we don't quote them. Open each host's pricing page on the same day and compare the 12, 24 or 36-month intro price and the renewal price side by side.
## Checkout and add-ons
Look carefully at both carts before you pay. Hosting checkouts often offer extras such as privacy protection, backups, security tools or email. Some are useful; many aren't needed on day one. Only keep what you'll actually use.
On Hostinger, check that WEBHOST2026 appears as a discount line; it lowers the hosting itself.
## cPanel vs hPanel
If you've used cPanel before, GoDaddy will feel familiar. hPanel does the same jobs (files, databases, email, DNS, backups) with a simpler layout, and most people find it easier after a day.
## Domains: keep at GoDaddy or move?
If you already have domains at GoDaddy, you can leave them there and change the nameservers to Hostinger's. Your site moves; your domain stays put. Transferring the domain itself is optional and can be done any time after the first 60 days of registration.
- [Claim your free domain on Hostinger](https://www.discountoffer.store/blog/hostinger-free-domain-how-to-claim)
## Verdict
- Choose Hostinger for website hosting on a budget with good speed.
- Choose GoDaddy if you want phone support and everything at the domain registrar you already use.
- Or combine them: domain at GoDaddy, hosting at Hostinger.
## FAQ
### Is Hostinger better than GoDaddy for hosting?
For most small sites, it's faster per dollar and easier to use. GoDaddy's main strength is domains.
### Can I use a GoDaddy domain with Hostinger?
Yes. Change the domain's nameservers in GoDaddy to the ones shown in hPanel. It usually takes effect within a few hours.
### Does Hostinger use cPanel?
No, it uses its own panel, hPanel, which covers the same features with a simpler layout.
---
# Hostinger vs SiteGround (2026): budget speed or premium support?
URL: https://www.discountoffer.store/blog/hostinger-vs-siteground
Published: 2026-10-16 · Category: Comparisons
> SiteGround is known for premium support and Google Cloud infrastructure; Hostinger for doing most of the same for much less. Where the extra money goes, and whether you need it.
## The short answer
SiteGround is a premium shared host with a strong reputation for support and a polished toolset. Hostinger gives you comparable speed for most sites at a much lower price, with more storage on its entry plans.
If budget matters, Hostinger. If you'll happily pay more for hands-on support and SiteGround's tools, SiteGround is a good host.
## Side by side
| | Hostinger | SiteGround |
| --- | --- | --- |
| Positioning | Budget, high value | Premium shared hosting |
| Entry price | From $2.49/mo (48 mo) | Higher; check their site |
| With an extra 20% coupon | About $1.99/mo | Varies by promotion |
| Infrastructure | Own data centers, LiteSpeed | Google Cloud |
| Dashboard | hPanel | Site Tools |
| Storage on entry plans | Generous (SSD/NVMe) | Smaller allowances |
| Staging | On higher plans | On higher plans |
| Support | 24/7 chat, AI assistant | 24/7 chat and tickets, strong reputation |
> Competitor prices change often and differ by country, so we don't quote them. Open each host's pricing page on the same day and compare the 12, 24 or 36-month intro price and the renewal price side by side.
## Where SiteGround's extra money goes
Mostly into support quality, its own caching and security tools, and Google Cloud's network. Those are real benefits, especially for agencies managing client sites.
For a single blog or small business site, though, Hostinger's LiteSpeed caching and CDN cover the speed side, and the price gap over a few years is large.
## Renewals
Both renew at a higher standard rate after the intro term. With Hostinger, a 48-month term keeps the low price for four years; check how long SiteGround's intro price lasts on the plan you're looking at.
- [How to pay less when Hostinger renews](https://www.discountoffer.store/blog/hostinger-renewal-price-how-to-pay-less)
## Verdict
- Choose Hostinger for the best price-to-performance and more storage.
- Choose SiteGround if premium support and its toolset are worth a higher bill to you.
## FAQ
### Is Hostinger as fast as SiteGround?
For most small and medium WordPress sites, the difference visitors notice is small once caching is on. Server location and your theme matter more.
### Why is SiteGround more expensive?
It positions itself as a premium host, with more spend on support and tooling, and runs on Google Cloud.
### Can I migrate from SiteGround to Hostinger?
Yes. Use Hostinger's free WordPress migration, check the copy, then switch DNS.
---
# Is Hostinger legit and safe? An honest look in 2026
URL: https://www.discountoffer.store/blog/is-hostinger-legit-and-safe
Published: 2026-10-16 · Category: Guides
> Who's behind Hostinger, how safe it is to pay, how good the uptime and security are, and the real downsides you should know before you buy.
## Short answer: yes
Hostinger is a real, long-running hosting company with millions of customers. It was founded in 2004 in Kaunas, Lithuania, runs data centers on several continents, and offers a 30-day money-back guarantee on hosting.
That doesn't mean it's perfect. Below is what it does well, and the downsides to plan for.
## Is it safe to pay Hostinger?
Payment happens on Hostinger's own secure checkout, over HTTPS, with the usual card processors and PayPal or local methods depending on your country. We never see your payment details: our link only adds the coupon to your cart.
## Security for your website
- Free SSL on every site.
- Malware scanning and a web application firewall on shared plans.
- Automatic backups (weekly on entry plans, daily on Business and up).
- Two-factor authentication for your hPanel login. Turn it on.
## The real downsides
- Renewals cost more than the intro price. Plan for it, and take a long first term.
- No phone support; it's 24/7 chat and tickets.
- Entry plans have weekly, not daily, backups.
- The checkout offers add-ons. Most aren't needed on day one.
- [How to pay less when Hostinger renews](https://www.discountoffer.store/blog/hostinger-renewal-price-how-to-pay-less)
## Who Hostinger is a good fit for
Bloggers, small businesses, students, freelancers and developers who want good speed for a low price and are comfortable with chat support. Large, mission-critical sites with a team may prefer a managed premium host.
- [Hostinger for bloggers](https://www.discountoffer.store/for/bloggers)
- [Hostinger for small businesses](https://www.discountoffer.store/for/small-business)
- [Hostinger for developers (Next.js & Node)](https://www.discountoffer.store/for/nextjs-node)
## Is our coupon legit?
Yes. WEBHOST2026 is an official Hostinger referral code. It was last tested at a real checkout in October 2026, and you'll see it as a discount line in your cart before you pay anything.
## FAQ
### Is Hostinger a scam?
No. It's an established hosting company founded in 2004, with a 30-day money-back guarantee on hosting.
### Where is Hostinger based?
Its headquarters are in Lithuania, and it runs data centers in North America, Europe, Asia and South America.
### Is Hostinger good for beginners?
Yes. hPanel is simple, WordPress installs in one click, and the AI assistant answers common setup questions.
---
# Hostinger coupon code: extra 20% off with WEBHOST2026 (October 2026)
URL: https://www.discountoffer.store/blog/hostinger-coupon-code-20-off
Published: 2026-10-16 · Category: Deals
> WEBHOST2026 takes an extra 20% off Hostinger's sale price on eligible web, WordPress, cloud and VPS plans. What it covers, real price examples, how to apply it, and how to check it worked before you pay.
## The code: WEBHOST2026
WEBHOST2026 is a Hostinger referral code. On eligible plans it adds an extra 20% discount on top of the sale price Hostinger is already showing, so you pay less than the headline "from" price.
It was last tested at a real Hostinger checkout in October 2026. The links on this site open Hostinger with the code already attached, so you don't have to type it.
## What the coupon works on
The extra discount applies to new purchases of Hostinger's main hosting products. These are the ones people use it for most:
- Web hosting: Single, Premium and Business.
- WordPress hosting: Premium WordPress, Business WordPress and the cloud WordPress tiers.
- Cloud hosting: Startup, Professional and Enterprise.
- VPS hosting: KVM 1, KVM 2, KVM 4 and KVM 8.
- Website Builder plans.
> Domains bought on their own, add-ons and renewals of a plan you already have are usually not discounted. If the discount line doesn't appear in your cart, the item isn't eligible; see the fixes guide linked below.
## What 20% off looks like in real prices
These are Hostinger's indicative USD sale prices on the 48-month term, and an estimate with the extra 20% applied. Tax, currency and the exact rounding come from the checkout.
| Plan | Sale price /mo | With WEBHOST2026 (est.) |
| --- | --- | --- |
| Single web hosting | $2.49 | $1.99 |
| Premium web hosting | $2.49 | $1.99 |
| Business web hosting | $3.49 | $2.79 |
| Cloud Startup | $7.99 | $6.39 |
| KVM 2 VPS | $6.99 | $5.59 |
- [See every plan and term on the pricing page](https://www.discountoffer.store/pricing)
## How to apply the coupon in 4 steps
It takes about a minute:
- Open Hostinger through a link on this site. The cart opens with WEBHOST2026 attached.
- Pick the plan, then pick the billing term. 48 months has the lowest monthly price.
- In the order summary, look for a discount line that mentions WEBHOST2026. If it's missing, click "Have a coupon code?", type WEBHOST2026 and apply.
- Create the account, choose a payment method and pay. The discount stays on the invoice.
- [The full step-by-step with screenshots described](https://www.discountoffer.store/blog/how-to-use-hostinger-coupon-webhost2026)
## Coupon code, promo code, referral link: what's the difference?
People search for all three, but at Hostinger they end up in the same place: a code in the cart that lowers the price. WEBHOST2026 is a referral code, which means it works both as a link (it attaches itself) and as a code you type in the coupon box.
Only one code can be active on an order. If you've pasted a different promo code, remove it first, or the cart will keep whichever was applied last.
## Which billing term gives the biggest saving?
The 20% is taken off whichever term you pick, so it saves the most money in total on the longest term. On Premium, the sale price drops from $3.49/mo on 12 months to $2.49/mo on 48 months, before the coupon.
The longer term also keeps the low price for longer, because the renewal rate only starts after the first term ends.
- [12 vs 24 vs 48 months compared](https://www.discountoffer.store/blog/12-vs-24-vs-48-month-hosting-which-saves-most)
## Is there a bigger Hostinger discount?
Hostinger runs its own sales through the year, and the headline percentage (up to 78% on some plans) is that sale price. WEBHOST2026 doesn't replace it; it stacks on top. So the cheapest way to buy is always: whatever sale is live, plus the extra 20% from the code.
Be careful with sites that promise 90% or 95% off. Those figures usually compare the 48-month sale price with the full renewal price, which isn't a coupon at all.
- [This month's live Hostinger deal](https://www.discountoffer.store/deals)
## Buying from outside the US
The code works on every Hostinger country store. Our link opens the store for your country, so prices show in your currency with your local payment methods and tax.
- [Coupon, currency and payment methods by country](https://www.discountoffer.store/hostinger-coupon-by-country)
- [United Kingdom (GBP, VAT)](https://www.discountoffer.store/hostinger-coupon-uk)
- [India (INR, UPI)](https://www.discountoffer.store/hostinger-coupon-india)
## FAQ
### Does WEBHOST2026 really give 20% off?
Yes, on eligible new hosting purchases. The extra 20% comes off Hostinger's sale price, and you can see it as a separate discount line in the order summary before you pay.
### Does the Hostinger coupon work for existing customers?
It works on new plans added to an existing account in most cases. It doesn't lower the renewal price of a plan you already have.
### Can I use two Hostinger coupons on one order?
No. Hostinger allows one code per order. WEBHOST2026 already stacks with the sale price, so there's nothing to gain from a second code.
### Does the coupon apply to the free domain?
The free domain is already free for the first year on plans that include it. The coupon lowers the hosting price itself.
### Can I get a refund if I use the coupon?
Yes. Hostinger's 30-day money-back guarantee covers hosting bought with a coupon. You get back what you actually paid. Domains are not refundable.
---
# How to start a blog with Hostinger in 2026 (step by step)
URL: https://www.discountoffer.store/blog/how-to-start-a-blog-with-hostinger
Published: 2026-10-15 · Category: Tutorials
> From zero to a live WordPress blog in under an hour: the plan to pick, your domain, WordPress setup, the only plugins you need, and your first steps for Google.
## What you need
- A blog name and a matching domain (the free one on Premium covers the first year).
- A hosting plan. Premium is the one we recommend for a new blog.
- About an hour.
## Step 1: Buy Premium hosting with the coupon
Open Hostinger through our link so WEBHOST2026 is applied, choose Premium and the 48-month term. That's $2.49/mo before the coupon, about $1.99/mo after.
## Step 2: Claim your free domain
In hPanel you'll be asked to claim the free domain. Keep it short, easy to spell and not tied to one narrow topic, so the blog can grow. A .com is the safest choice.
- [Free domain: which plans include it and how to claim it](https://www.discountoffer.store/blog/hostinger-free-domain-how-to-claim)
## Step 3: Install WordPress
Hostinger's setup wizard offers to install WordPress for you. Accept, set an admin email you check, and use a strong password. SSL is turned on automatically.
## Step 4: Pick a fast, simple theme
Choose a lightweight theme (the default block themes are fine) rather than a heavy multipurpose one. Speed and readability matter more than effects.
## Step 5: Install only the plugins you need
- An SEO plugin, for titles, descriptions and your XML sitemap.
- LiteSpeed Cache, which Hostinger usually installs and configures for you.
- An anti-spam plugin for comments.
- A backup plugin, if you're on a plan with weekly backups and want more frequent ones.
## Step 6: Create the pages every blog needs
- About
- Contact
- Privacy policy
- Affiliate or ad disclosure, if you'll earn from the blog
## Step 7: Publish, then tell Google
Write your first three to five posts on questions your readers actually search for. Then add your site to Google Search Console and submit the sitemap from your SEO plugin, so Google starts crawling it.
## Which plan as you grow
Premium will carry most blogs a long way. Once the blog earns money or traffic is steady, Business ($3.49/mo, 48 months) adds daily backups and more resources.
- [Hostinger for bloggers](https://www.discountoffer.store/for/bloggers)
## FAQ
### How much does it cost to start a blog?
About $1.99/mo on Premium for 48 months with WEBHOST2026, plus nothing for the domain in year one.
### Do I need to know how to code?
No. WordPress and Hostinger's setup wizard handle the technical parts.
### How long until my blog shows in Google?
Usually days to a few weeks after you submit the sitemap. Ranking well takes longer and depends on your content.
---
# Hostinger coupon not working? 8 fixes that actually help
URL: https://www.discountoffer.store/blog/hostinger-coupon-not-working-fixes
Published: 2026-10-15 · Category: Deals
> If WEBHOST2026 or any Hostinger promo code won't apply, it's almost always one of eight things. Check them in this order and you'll know within two minutes whether it's fixable.
## First, check what the cart is actually showing
Open the order summary on the right side of the cart. A working code shows as its own discount line, and the total drops. If you see the code name but no discount, it's been accepted but the item isn't eligible. If you see an error like "invalid coupon", it hasn't been accepted at all. The fixes below are split by which one you're seeing.
## 1. Another code is already in the cart
Hostinger allows one code per order. Browser extensions that auto-try codes often leave an expired one in place. Remove it with the × next to it, then apply the one you want.
## 2. A typo or extra space
Codes are matched exactly. Copy WEBHOST2026 rather than typing it, and make sure there's no space at the end, which phones often add. Better still, use a link from this site, which attaches it without typing.
## 3. The item isn't eligible
Coupons apply to hosting plans. They usually don't apply to:
- A domain bought on its own.
- Add-ons like extra backups, priority support or an extra email box.
- The renewal of a plan you already have.
- Upgrades from one plan to another inside the same subscription.
## 4. You're renewing, not buying
If the cart was opened from a renewal reminder email, it's a renewal order. Coupons for new purchases won't reduce it. You can still lower a renewal; there are a few honest ways covered in the renewal guide.
- [How to pay less when Hostinger renews](https://www.discountoffer.store/blog/hostinger-renewal-price-how-to-pay-less)
## 5. You're on a different country store
Hostinger has separate stores per country (hostinger.com/uk, /in, /ca and so on). Prices and some promotions differ. If the code fails on one, open the cart again through our link, which goes to the store the code was tested on.
## 6. An old cart or cookie is stuck
An old cart can keep its previous discount. Open the link in a private window, or clear cookies for hostinger.com, then try again. This fixes more cases than you'd expect.
## 7. The term is too short
Some promotions only apply to longer terms, and monthly billing is often excluded. Switch the term to 12, 24 or 48 months and watch whether the discount line appears.
## 8. The code has changed
Codes do get retired. WEBHOST2026 was last confirmed working in October 2026; the badge on this site only moves when we re-test it. If none of the above fixes it, message us and we'll check it at a live checkout.
- [Contact us](https://www.discountoffer.store/contact)
## FAQ
### Why does Hostinger say my coupon is invalid?
Usually a typo, a trailing space, or another code already in the cart. Remove other codes, copy the code exactly, and apply it again.
### The code applied but my price didn't change. Why?
The item in the cart isn't eligible, most often a renewal, a standalone domain or an add-on. Coupons lower the price of new hosting plans.
### Can I add a coupon after I've paid?
No. Hostinger doesn't apply codes to orders that are already paid. If you paid within the last 30 days, you can ask for a refund and buy again with the code, but you'd lose any setup done in the meantime.
---
# How to make a website with Hostinger: Website Builder or WordPress?
URL: https://www.discountoffer.store/blog/how-to-make-a-website-with-hostinger
Published: 2026-10-14 · Category: Tutorials
> Two ways to build a site on Hostinger, explained side by side. Which to choose for a business, portfolio or store, and the steps for each.
## Two ways to build
Hostinger's Website Builder is drag-and-drop with an AI that drafts your first version. WordPress is more flexible, with thousands of themes and plugins, but takes a little longer to learn. Both are included with hosting plans, and the coupon works on both.
| | Website Builder | WordPress |
| --- | --- | --- |
| Setup time | Minutes | About an hour |
| Learning curve | Very low | Moderate |
| Flexibility | Good for most small sites | Almost unlimited |
| Online store | Built in | WooCommerce plugin |
| Best for | Small business, portfolio, simple store | Blogs, content sites, custom features |
## Building with the Website Builder
- Choose a Website Builder or Premium plan.
- Describe your business in a sentence or two; the AI generates a draft site with text and images.
- Edit sections by dragging and typing. Replace stock images with your own.
- Connect your domain and publish.
- [Website Builder plans and features](https://www.discountoffer.store/hosting/website-builder)
## Building with WordPress
- Choose Premium (or a WordPress plan).
- Let the setup wizard install WordPress.
- Pick a lightweight theme and build your pages with the block editor.
- Add an SEO plugin, then publish.
- [Step-by-step: start a blog with Hostinger](https://www.discountoffer.store/blog/how-to-start-a-blog-with-hostinger)
## Which should you choose?
If you want a good-looking site live today and don't plan to add custom features, use the Website Builder. If you'll publish a lot of content, want specific plugins, or might hand the site to a developer later, use WordPress.
- [Hostinger for small businesses](https://www.discountoffer.store/for/small-business)
- [Hostinger for online stores](https://www.discountoffer.store/for/online-stores)
## FAQ
### Is the Hostinger Website Builder free?
It's included with Website Builder and most web hosting plans; there's no separate free version for custom domains.
### Can I switch from the Website Builder to WordPress later?
Not automatically; you'd rebuild the pages in WordPress. If you think you'll need WordPress, start there.
### Can I sell products?
Yes, with either: the Builder has a store built in, and WordPress uses WooCommerce.
---
# Hostinger WordPress hosting coupon: 20% off and which plan to buy
URL: https://www.discountoffer.store/blog/hostinger-wordpress-hosting-coupon
Published: 2026-10-14 · Category: Deals
> Get an extra 20% off Hostinger's managed WordPress hosting with WEBHOST2026. Premium vs Business WordPress compared, what "managed" actually includes, and how to move an existing site for free.
## The deal in one line
Hostinger's WordPress plans start at $2.49/mo on a 48-month term. WEBHOST2026 takes an extra 20% off that, which brings it to about $1.99/mo before tax.
## Premium vs Business WordPress
Both are managed WordPress hosting on LiteSpeed servers. The difference is how much room you get and how often you're backed up.
| | Premium WordPress | Business WordPress |
| --- | --- | --- |
| Price, 48 mo | $2.49/mo | $3.49/mo |
| With WEBHOST2026 (est.) | $1.99/mo | $2.79/mo |
| Best for | A blog, portfolio or brochure site | A WooCommerce store or several busy sites |
| Backups | Weekly | Daily, with on-demand restore |
| Storage | 100 GB SSD | 200 GB NVMe |
| Object cache | No | Yes |
> If you're selling with WooCommerce, take Business. Daily backups matter the first time a plugin update breaks your checkout, and object caching keeps cart pages fast.
## What "managed" includes
You still own the site, but Hostinger handles the plumbing:
- WordPress installs in one click, with SSL already on.
- Core updates are automatic; plugin updates can be automatic with rollback if something breaks.
- LiteSpeed Cache is preinstalled and configured, which is most of the speed work done.
- Malware scanning and a web application firewall run in the background.
## Moving an existing WordPress site
Hostinger has a free migration tool in hPanel. Give it your current site's admin login (or upload a backup), and it copies files and database across. Your old host keeps running until you change the domain's DNS, so there's no downtime if you switch over after checking the copy.
## Is shared web hosting enough for WordPress?
Yes. Premium web hosting is $2.49/mo, the same as Premium WordPress, and runs WordPress on the same one-click installer. The WordPress plans simply come with WordPress set up and tuned from the start. The coupon works on both, so pick the dashboard you prefer.
- [WordPress hosting plans and features](https://www.discountoffer.store/hosting/wordpress-hosting)
- [Hostinger for WordPress sites](https://www.discountoffer.store/for/wordpress)
## FAQ
### Does the Hostinger coupon work on WordPress hosting?
Yes. WEBHOST2026 applies to new Premium WordPress, Business WordPress and the cloud WordPress plans.
### Is Hostinger good for WooCommerce?
Business WordPress or cloud hosting handle a small to medium WooCommerce store well. For a very busy store, start on cloud hosting so you don't need to move later.
### Is WordPress migration to Hostinger really free?
Yes. The automatic migration in hPanel is free on WordPress and web hosting plans, and support can help if it fails.
---
# Hostinger VPS coupon code: extra 20% off KVM 1 to KVM 8
URL: https://www.discountoffer.store/blog/hostinger-vps-coupon-code
Published: 2026-10-12 · Category: Deals
> Save an extra 20% on Hostinger KVM VPS plans with WEBHOST2026. Real prices per plan, which size fits your app, and why the 24-month term is often the smart pick for a VPS.
## Prices with the coupon
Indicative USD sale prices for Hostinger's KVM VPS plans on a 24-month term, and the estimate with WEBHOST2026's extra 20%:
| Plan | Sale price /mo (24 mo) | With WEBHOST2026 (est.) | Good for |
| --- | --- | --- | --- |
| KVM 1 | $5.99 | $4.79 | One small app or API |
| KVM 2 | $7.99 | $6.39 | App + database, most people |
| KVM 4 | $13.99 | $11.19 | Several apps, Docker builds |
| KVM 8 | $26.99 | $21.59 | High-traffic production |
## Which KVM plan should you pick?
Size it by RAM, because that's what runs out first. Node, Next.js, a database and a reverse proxy together comfortably fit in the RAM of KVM 2. KVM 1 is fine for one lightweight service. Go to KVM 4 if you build Docker images on the server or run several apps side by side.
You can upgrade later from hPanel without reinstalling, so starting one size small is safe.
## 24 or 48 months for a VPS?
48 months is cheapest per month (KVM 2 is $6.99/mo vs $7.99/mo on 24). But with a VPS, your needs change faster than with a blog. 24 months is a good middle ground: most of the saving, half the upfront cost, and a natural point to resize.
## What you get on every Hostinger VPS
- Full root access and a choice of Linux templates, including ones with Docker preinstalled.
- Dedicated KVM resources and NVMe storage, not shared with other customers.
- A dedicated IPv4 address and DDoS protection.
- Kodee, the built-in AI assistant, for commands and troubleshooting.
- Snapshots and weekly backups.
## Setting it up
If you're deploying a JavaScript app, these walk through the whole thing, from a blank server to HTTPS:
- [Deploy a Next.js app on a Hostinger VPS](https://www.discountoffer.store/blog/deploy-nextjs-app-on-hostinger-vps)
- [Host a MERN stack app cheaply](https://www.discountoffer.store/blog/host-mern-stack-app-cheaply-2026)
- [Hostinger VPS vs DigitalOcean](https://www.discountoffer.store/blog/hostinger-vps-vs-digitalocean-droplet)
- [VPS plans and features](https://www.discountoffer.store/hosting/vps-hosting)
## FAQ
### Does the Hostinger coupon work on VPS?
Yes. WEBHOST2026 applies to new KVM 1, KVM 2, KVM 4 and KVM 8 orders on 12, 24 and 48-month terms.
### Can I upgrade a Hostinger VPS later?
Yes. Upgrades are done from hPanel and keep your data. Downgrades are more limited, which is another reason to start small.
### Is a Hostinger VPS managed?
No. You manage the operating system and software yourself, with help from Kodee and support. If you want no server work at all, cloud hosting is the managed option.
---
# Hostinger renewal price: why it goes up and 5 ways to pay less
URL: https://www.discountoffer.store/blog/hostinger-renewal-price-how-to-pay-less
Published: 2026-10-10 · Category: Guides
> Hostinger's low price covers your first term only. What the renewal really costs, whether a coupon helps, and the honest ways to keep your hosting bill down for years.
## Why the renewal is higher
Every big host prices this way. The sale price is an introductory price for the first term you buy. When that term ends, the plan renews at the standard rate, which is often two to three times higher. It's not a hidden fee; it's shown in the cart, usually in small print under the price.
## Does a coupon lower the renewal?
No. WEBHOST2026 and other referral codes apply to new purchases. They take 20% off the first term, not the renewal. Anyone promising a "renewal coupon" is usually describing one of the methods below.
## 1. Lock in the longest term you can
This is the biggest lever. On a 48-month term you pay the sale price, minus the extra 20%, for four years before the renewal rate ever applies. On 12 months you hit it after one.
- [12 vs 24 vs 48 months compared](https://www.discountoffer.store/blog/12-vs-24-vs-48-month-hosting-which-saves-most)
## 2. Renew for a long term, not monthly
Renewal prices also get cheaper per month on longer terms. When renewal time comes, pick 24 or 48 months rather than letting it roll month to month.
## 3. Check for a renewal offer before it renews
Hostinger sometimes shows a discounted renewal in hPanel or by email in the weeks before your plan expires. Turn off auto-renew a few weeks early, check the billing section, and renew manually if there's an offer.
## 4. Don't pay for more than you use
If you bought Business but run one small site, renewing on Premium or Single saves real money. Check your actual storage and traffic in hPanel before you renew.
- [Which Hostinger plan you actually need](https://www.discountoffer.store/blog/hostinger-plans-explained-which-to-choose)
## 5. Move to a new plan as a new purchase
Buying a new plan with a coupon and migrating to it is allowed, and on a small site the migration is quick. It takes some work and you need to move the domain, so only do it if the saving is worth an afternoon.
## Renewals in your currency
Renewal prices are set per country store, so they differ from the USD figures. Your country page explains the local currency and tax, and the cart always shows the renewal rate before you pay.
- [Hostinger coupon by country](https://www.discountoffer.store/hostinger-coupon-by-country)
## FAQ
### How much does Hostinger renew at?
It depends on the plan and term. The renewal price is shown in the cart when you buy, and in hPanel's billing section afterwards. Expect two to three times the introductory price.
### Can I turn off auto-renew on Hostinger?
Yes, in hPanel under Billing. Your plan keeps running until the end of the term you paid for.
### Does Hostinger warn me before renewing?
Yes. Hostinger emails renewal reminders before the term ends, to the address on your account.
---
# Hostinger free domain: which plans include it and how to claim it
URL: https://www.discountoffer.store/blog/hostinger-free-domain-how-to-claim
Published: 2026-10-08 · Category: Guides
> Most Hostinger plans come with a free domain for the first year. Which ones qualify, how to claim it in hPanel, what it costs after year one, and the mistake that loses it.
## Which plans include a free domain
A free domain for the first year comes with Premium and Business web hosting, Premium WordPress and up, and cloud hosting, on 12-month or longer terms. The Single plan and VPS plans don't include one.
Coupon WEBHOST2026 doesn't affect the free domain. You get both: the extra 20% off the hosting and the domain at no cost.
## How to claim it
- Log in to hPanel after paying.
- You'll see a "Claim domain" prompt on the home screen. If not, go to Domains and look for the free domain voucher.
- Search for the name you want and pick an eligible extension (.com, .net, .online and others).
- Fill in the owner details. Use your own name and email, so the domain is legally yours.
> Claim it soon. The voucher is tied to your hosting plan, and if you cancel the plan inside the 30-day refund window, the domain's cost is taken from the refund.
## What it costs after the first year
From year two, the domain renews at Hostinger's normal price for that extension. A .com is a modest yearly fee; some cheap-looking extensions renew much higher. Check the renewal price on the search screen before you pick one.
## Already own a domain?
You can point an existing domain at Hostinger by changing its nameservers, or transfer it in. You can still claim the free domain voucher for a second name, which is handy for a brand or a redirect.
## Country domains (.co.uk, .ca, .com.au, .pk)
Many country domains can be registered at Hostinger, and some are covered by the free voucher. A few have eligibility rules (.com.au needs an Australian business number, .ca needs a Canadian presence), and some, like .pk, are only sold through local registrars. If yours isn't offered, register it elsewhere and point it at Hostinger with nameservers.
- [Hostinger for small businesses](https://www.discountoffer.store/for/small-business)
- [Web hosting plans with a free domain](https://www.discountoffer.store/hosting/web-hosting)
## FAQ
### Is the Hostinger free domain really free?
Yes, for the first year on eligible plans and terms. From year two it renews at the normal price for that extension.
### Do I get a free domain with Hostinger Single?
No. The free domain starts on Premium web hosting. Single is the cheapest plan and leaves it out.
### What happens to the domain if I cancel the hosting?
The domain is yours and stays registered until its term ends. If you cancel within 30 days for a refund, the domain fee is deducted from what you get back.
---
# How to buy Hostinger in Pakistan with JazzCash (step by step)
URL: https://www.discountoffer.store/blog/buy-hostinger-in-pakistan-with-jazzcash
Published: 2026-10-04 · Category: Guides
> Pay for Hostinger in rupees with JazzCash, without an international card. Every screen from plan to payment, what to do if JazzCash fails, and the Easypaisa question answered.
## The short version
Hostinger has a Pakistan store at hostinger.com/pk that bills in rupees and lists JazzCash as a payment method, along with cards and crypto. You don't need a dollar card or a friend abroad. The whole thing takes about ten minutes.
Below, every step is in the order you'll see it. If you only need the code, it's WEBHOST2026, and the links on this site add it for you.
## Before you start
Have these ready so the payment step doesn't time out:
- A JazzCash mobile account with enough balance for the full upfront amount, not just one month.
- The phone that has that JazzCash account, because you approve the payment on it.
- An email address you'll keep. Your hosting account, invoices and renewal notices all go there.
> You pay the whole term upfront. Premium at 48 months is shown per month, but the charge is the monthly price × 48. Check the upfront total in the cart, then top up your wallet before you start.
## Step 1 — Open the Pakistan store with the coupon
Use a discount link from this site. It opens hostinger.com/pk with WEBHOST2026 already in the cart, so prices show in rupees and the discount is applied without typing anything.
If you open Hostinger some other way, check the address bar shows /pk and the prices show Rs. Otherwise you're on a dollar store and JazzCash won't be offered.
## Step 2 — Pick the plan and term
For a website or blog, choose Premium (Rs 599/mo on 48 months). For a Node or Next.js app, choose the KVM 1 VPS (Rs 2,099/mo on 24 months).
The longest term gives the lowest monthly price. Shorter terms cost more per month but less upfront, which can matter if you're paying from a wallet balance.
## Step 3 — Create the account
Sign up with email, or Google. Use your own details, not a client's or a freelancer's, so you never lose access to the account the site runs on.
## Step 4 — Choose JazzCash and approve
On the payment step, choose JazzCash, enter the mobile number linked to your wallet, and submit. You'll get a payment request to approve on your phone, in the JazzCash app or through the prompt JazzCash sends.
Before you approve, check the order summary shows WEBHOST2026 and a discount line. If it doesn't, go back to the cart and add the code there.
> Approve the request promptly. Wallet payment requests expire after a short window, and if it times out you just start the payment step again.
## If JazzCash fails
The usual causes, most common first:
- Not enough balance for the full upfront amount. Top up, or pick a shorter term.
- Daily or monthly wallet limit reached. These depend on your account level; a fully verified account has higher limits.
- The request expired before you approved it. Retry the payment step.
- JazzCash isn't shown at all. You're probably not on the /pk store. Reopen it through a link on this site.
## What about Easypaisa?
Easypaisa is not on Hostinger's official payment list for Pakistan. If it isn't offered at your checkout, you have two options: pay with a debit card linked to your Easypaisa or bank account (with online/international transactions turned on), or move the money to JazzCash and pay that way.
If a site tells you Easypaisa works directly, check the checkout yourself before you plan around it.
## After you pay
You'll land in hPanel, Hostinger's dashboard. Claim the free domain if your plan includes one, then set up the website or VPS. The invoice is emailed to you and can be downloaded from the billing section anytime.
You have 30 days to ask for a refund on hosting if it isn't working out. Domain registrations aren't refundable.
---
# Move a Next.js app from Vercel to a Hostinger VPS
URL: https://www.discountoffer.store/blog/migrate-from-vercel-to-hostinger-vps
Published: 2026-10-03 · Category: Tutorials
> What actually changes when you leave Vercel: env vars, images, cron, storage, analytics and DNS. A migration checklist with no downtime, plus what you'll miss.
## Should you move at all?
Vercel is excellent for a team that relies on per-branch preview deployments and doesn't want to run a server. People usually leave for one of three reasons: the bill grew with traffic or seats, a function hit a timeout or size limit, or they want a database and background jobs on the same machine as the app.
If one of those is you, a VPS like Hostinger's KVM 1 (Rs 2,099/mo on 24 months, 4 GB RAM) runs most Next.js apps for a flat monthly price. If none of them apply, staying on Vercel is a reasonable choice.
## Step 1 — Set up the server first
Get the VPS running before you touch DNS. Follow our full guide to deploying Next.js on a Hostinger VPS for Node 24, standalone output, PM2 and Nginx. This article only covers what's different when you're coming from Vercel.
Do the whole setup on the server's IP address first. Your Vercel site stays live the entire time.
## Step 2 — Bring your environment variables
Vercel stores env vars per environment. Pull the production set down with the CLI, check it, and copy it to the server. Remove anything Vercel set automatically (`VERCEL_*`) — your app shouldn't depend on those off-platform.
On your laptop, in the linked project:
```bash
npx vercel env pull .env.production --environment=production
# Inspect it, delete VERCEL_* lines, then copy it up
scp .env.production deploy@YOUR_SERVER_IP:/home/deploy/app/.env.production
```
> `NEXT_PUBLIC_*` variables are baked in at build time. Put them on the server before you run `next build`, or the client bundle ships with them undefined.
## Step 3 — Check the Vercel-only features you use
Most of Next.js works the same under `next start`. These are the pieces that need attention:
| On Vercel | On your VPS |
| --- | --- |
| Image Optimization | Works under `next start`. Make sure `sharp` is installed; standalone builds pick it up automatically. |
| ISR / revalidate | Works. The cache lives on disk in `.next`, which is fine for one server. |
| Middleware / proxy | Works. It runs in the same Node process. |
| Vercel Cron Jobs | Replace with a crontab entry that calls the same route (example below). |
| Vercel Postgres / KV / Blob | These are hosted services. Keep using them over the network, or move to Postgres/Redis on the VPS. |
| @vercel/analytics, Speed Insights | Vercel-only. Remove them, or switch to Plausible, Umami or GA4. |
| Preview deployments | Not included. Keep Vercel for previews if your team needs them. |
## Step 4 — Replace Vercel Cron
If `vercel.json` has a `crons` block, each entry is just a scheduled GET request to a route. Do the same with cron on the server, and protect the route with a secret so nobody else can trigger it.
`crontab -e` as the deploy user. This runs /api/cron/daily every day at 03:00 server time:
```bash
0 3 * * * curl -fsS -H "Authorization: Bearer $CRON_SECRET" https://yourdomain.com/api/cron/daily > /dev/null
```
> Cron doesn't load your `.env` file. Either define `CRON_SECRET=...` at the top of the crontab, or call a small script that sources the env file first.
## Step 5 — Test before switching DNS
You can request the real domain from the new server without changing DNS for anyone else. `curl --resolve` sends the request to your VPS IP while still using your domain name:
- Click through the main pages with your hosts file pointed at the VPS.
- Submit a form, log in, and trigger the cron route once by hand.
- Check `pm2 logs` for errors while you do it.
```bash
curl -I --resolve yourdomain.com:80:YOUR_SERVER_IP http://yourdomain.com/
```
## Step 6 — Switch DNS with no downtime
A day before, lower the TTL on your A/CNAME records to 300 seconds so the switch spreads quickly. On the day, point the A record at the VPS IP. Once it resolves to the new server, run Certbot (or let Caddy) issue the HTTPS certificate.
Leave the Vercel project running for a couple of days. Visitors whose DNS is still cached keep landing on a working site. Once traffic in Vercel's dashboard drops to zero, remove the domain from the project.
> If you used Vercel's nameservers, move DNS to your registrar or Hostinger first, recreate every record (MX, TXT, verification records included), and only then change the A record. Losing the MX record is how email silently breaks during a migration.
## What you'll miss
Being honest about the trade-off: no preview URL per pull request, no instant rollback button (`git checkout` the previous commit and redeploy instead), and no global edge network unless you put Cloudflare in front. You also become the person who installs security updates.
In return you get a fixed monthly bill, no function timeouts, and one machine that can run your app, database, workers and every side project at once. If that's the trade you want, coupon WEBHOST2026 applies through the links on this site.
---
# Hostinger review 2026: is it worth it in Pakistan?
URL: https://www.discountoffer.store/blog/hostinger-review-2026-pakistan
Published: 2026-10-02 · Category: Reviews
> PKR pricing, JazzCash payment, real renewal costs, speed from Pakistan, and who should pick something else. An honest verdict for Pakistani buyers.
## Verdict first
For most people in Pakistan starting a website, Hostinger is the easiest good choice: rupee pricing, JazzCash payment, a dashboard beginners can use, and an entry price that's hard to beat. The catch is renewal. Plan around the renewal price from day one and it stays good value.
Developers should look at the VPS rather than shared hosting. 4 GB of RAM on the entry plan is the standout spec.
## What it costs in 2026
Promotional rupee prices on hostinger.com/pk, before the coupon:
| Plan | Promo / month | Term | Renews at |
| --- | --- | --- | --- |
| Single | Rs 399 | 48 months | Rs 999/mo |
| Premium | Rs 599 | 48 months | Rs 1,699/mo |
| Unlimited | Rs 799 | 48 months | Rs 2,299/mo |
| KVM 1 VPS | Rs 2,099 | 24 months | Rs 3,399/mo |
| KVM 2 VPS | Rs 2,699 | 24 months | Rs 4,099/mo |
> Renewal is roughly 1.5–3× the promo rate across the range, and highest on the shared plans. That's normal in this industry, but it's the number to plan your budget around.
## What's genuinely good
- Pay in rupees with JazzCash or a local debit card. No dollar card needed and no currency conversion fees.
- hPanel is simpler than cPanel for beginners, and WordPress installs in one click with caching already set up.
- LiteSpeed servers and a CDN on most plans make WordPress fast without plugins.
- Free domain for a year on Premium and up, with free mailboxes for the first year.
- The VPS gives you 4 GB RAM on the entry tier, plus root access and snapshots.
- 30-day money-back on hosting, so it's low risk to try.
## What's not
- Renewal pricing is steep, and the best monthly price requires paying 4 years upfront.
- Premium hosts 3 websites. If you run lots of small sites, budget for Unlimited.
- There's no data centre in Pakistan. Pick the nearest location offered when you set up. For Pakistani visitors, a CDN does more for speed than the server location.
- Support is chat and tickets, not phone. It's 24/7 and usually quick, but you can't call anyone.
- Upsells at checkout (extra domain privacy, email, SEO tools) add up. Untick what you don't need.
## Who should buy it
- Students and freelancers who want a portfolio or client sites, paid with JazzCash.
- Small businesses that want a website and email on their own domain, billed in rupees.
- Developers who want an affordable VPS for Next.js, Node or Docker.
## Who should pick something else
- Anyone who needs a .pk-only setup with local phone support. A local Pakistani host may suit you better.
- Teams that rely on per-branch preview deploys. Stay on Vercel or Netlify for the frontend.
- If you only need hosting for a few months, the short-term prices take away most of the advantage.
## How to get the lowest price
Buy the longest term you're comfortable with through the Pakistan store, and use coupon WEBHOST2026 on top of the sale price. The links on this site open hostinger.com/pk with the code already applied.
---
# Deploy a Next.js app on Hostinger VPS (step by step)
URL: https://www.discountoffer.store/blog/deploy-nextjs-app-on-hostinger-vps
Published: 2026-09-12 · Updated: 2026-10-17 · Category: Tutorials
> A complete walkthrough: provision the server, install Node 24, build with standalone output, keep it alive with PM2, put Nginx and free HTTPS in front, and script your redeploys.
## Why a VPS, and not shared hosting
A Next.js app that uses server components, route handlers, ISR or any kind of server rendering is a long-lived Node process. Shared hosting is built to run PHP scripts that start and die inside a single request — there is no supervisor to keep `node` running, no way to bind a port, and usually no SSH. That is the whole reason this guide starts with a VPS.
The exception is a fully static site. If your app runs with `output: 'export'` and has no server features at all, you can drop the generated HTML onto any shared plan and skip everything below. Everything else needs a real server.
The entry-tier KVM 1 is enough for a small-to-medium Next.js site: 1 vCPU, 4 GB RAM and 50 GB NVMe. RAM is the spec that matters most here, because `next build` is memory-hungry and 4 GB at this price point is unusually generous.
## What you need before you start
Five minutes of setup saves an hour of debugging later.
- A VPS running Ubuntu 24.04 LTS or 26.04 LTS — pick the OS template when you create the server.
- A domain with an A record pointing at your VPS's IP address. Set this up first; DNS takes time to propagate and Let's Encrypt will fail without it.
- Your app in a Git repository the server can reach.
- Your SSH public key added to the server during provisioning — far safer than a root password.
> Add the A record before anything else. Certbot verifies domain ownership over HTTP, so if DNS has not propagated by the time you reach the HTTPS step, the certificate request fails and you wait.
## Step 1 — Log in and create a deploy user
Running your app as root is the single most common mistake in VPS tutorials. Create an unprivileged user that owns the app, and reserve root for package installs.
From your laptop, connect as root, then create the deploy user:
```bash
ssh root@YOUR_SERVER_IP
adduser --disabled-password --gecos "" deploy
usermod -aG sudo deploy
# Copy your SSH key across so you can log in as deploy
rsync --archive --chown=deploy:deploy ~/.ssh /home/deploy/
```
Lock the front door before you install anything:
```bash
ufw allow OpenSSH
ufw allow 'Nginx Full'
ufw --force enable
ufw status
```
> `ufw allow 'Nginx Full'` opens ports 80 and 443. That profile only exists after Nginx is installed — if the command errors, install Nginx first (Step 5) and come back.
## Step 2 — Install Node.js 24 LTS
As of September 2026, Node 24 (Krypton) is the Active LTS line and the right default for new deployments. Node 22 is in maintenance until April 2027, so existing apps are not in danger, but new servers should start on 24.
Ubuntu's own `apt` repository ships an old Node. Use NodeSource instead so you get the version you actually asked for.
Log out and back in as `deploy`, then:
```bash
curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -
sudo apt-get install -y nodejs
node -v # v24.x.x
npm -v
```
## Step 3 — Add swap if you are on a 1 vCPU plan
`next build` can spike well past 1 GB of memory on a mid-sized app. With 4 GB of RAM you are usually fine, but a swap file costs nothing and turns a hard out-of-memory crash into a merely slow build. On smaller servers it is not optional.
Create a 2 GB swap file that survives reboots:
```bash
sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
free -h # confirm swap is listed
```
> If a build still dies with `JavaScript heap out of memory`, raise Node's heap ceiling for that command: `NODE_OPTIONS="--max-old-space-size=3072" npm run build`.
## Step 4 — Clone, configure and build with standalone output
Setting `output: 'standalone'` in your Next config is the highest-value change you can make for a VPS deployment. Next.js traces exactly which files each page needs and copies them — plus a minimal `server.js` — into `.next/standalone`. You end up shipping a fraction of `node_modules`, which means faster deploys and a smaller disk footprint.
There is one catch that trips up almost everyone: the standalone folder does not include `public` or `.next/static`, because Next.js assumes a CDN will serve them. Copy them in yourself and `server.js` will serve them automatically.
next.config.ts
```ts
import type { NextConfig } from "next";
const nextConfig: NextConfig = {
output: "standalone",
};
export default nextConfig;
```
Clone into /var/www, install and build:
```bash
sudo mkdir -p /var/www && sudo chown deploy:deploy /var/www
cd /var/www
git clone https://github.com/you/your-app.git myapp
cd myapp
npm ci
npm run build
# The bit everyone forgets:
cp -r public .next/standalone/
cp -r .next/static .next/standalone/.next/
```
> Environment variables prefixed with `NEXT_PUBLIC_` are inlined into the browser bundle at build time, not read at runtime. If you change one, you must rebuild — restarting the process will not pick it up. Put your `.env.production` in place before `npm run build`.
## Step 5 — Keep it running with PM2
Your app needs to restart when it crashes and come back after a reboot. PM2 handles both. Point it at the standalone `server.js` rather than `next start` — the minimal server boots faster and does not need the full dependency tree.
Bind to `127.0.0.1`, not `0.0.0.0`. The Node process should only be reachable from Nginx on the same machine; anything else means people can bypass your reverse proxy by hitting port 3000 directly.
Start the app and register it with systemd:
```bash
sudo npm install -g pm2
cd /var/www/myapp
PORT=3000 HOSTNAME=127.0.0.1 pm2 start .next/standalone/server.js --name myapp
pm2 save
pm2 startup systemd
# PM2 prints a sudo command — copy it, run it, then run 'pm2 save' again.
```
Useful day-to-day commands:
```bash
pm2 status
pm2 logs myapp --lines 100
pm2 restart myapp
pm2 monit
```
## Step 6 — Put Nginx in front
The Next.js self-hosting documentation recommends a reverse proxy rather than exposing the Node server directly, and the reasoning is worth understanding: Nginx absorbs malformed requests, slow-connection attacks, oversized payloads and rate limiting, so your Node process spends its CPU rendering pages instead of validating junk traffic.
The `location /_next/static/` block below is an easy win. Those files are content-hashed and immutable, so letting Nginx serve them straight off disk with a long cache header takes that load off Node entirely.
```bash
sudo apt-get install -y nginx
sudo nano /etc/nginx/sites-available/myapp
```
/etc/nginx/sites-available/myapp
```nginx
server {
listen 80;
server_name example.com www.example.com;
# Immutable, content-hashed assets — let Nginx serve them directly.
location /_next/static/ {
alias /var/www/myapp/.next/static/;
expires 365d;
add_header Cache-Control "public, max-age=31536000, immutable";
access_log off;
}
location / {
proxy_pass http://127.0.0.1:3000;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_cache_bypass $http_upgrade;
}
}
```
Enable the site and reload:
```bash
sudo ln -s /etc/nginx/sites-available/myapp /etc/nginx/sites-enabled/
sudo rm -f /etc/nginx/sites-enabled/default
sudo nginx -t
sudo systemctl reload nginx
```
> Always run `sudo nginx -t` before reloading. It catches config typos while the old config is still serving traffic.
## Step 7 — Free HTTPS with Let's Encrypt
Certbot edits your Nginx config, installs the certificate and sets up automatic renewal in one command. Renewal runs on a systemd timer, so this is genuinely fire-and-forget.
```bash
sudo apt-get install -y certbot python3-certbot-nginx
sudo certbot --nginx -d example.com -d www.example.com
# Confirm auto-renewal works
sudo certbot renew --dry-run
```
## Step 8 — A one-command redeploy
Doing all of the above by hand every time you ship is how mistakes happen. Save this script and your deploys become a single command.
/var/www/myapp/deploy.sh — then `chmod +x deploy.sh`
```bash
#!/usr/bin/env bash
set -euo pipefail
cd /var/www/myapp
git pull origin main
npm ci
npm run build
# Standalone output does not include these — copy them every build.
cp -r public .next/standalone/
cp -r .next/static .next/standalone/.next/
pm2 restart myapp --update-env
pm2 save
echo "Deployed at $(date -Iseconds)"
```
> `set -euo pipefail` matters here. Without it, a failed `npm run build` would sail past the error and restart PM2 on a half-built app.
## Gotchas worth knowing before they bite
Most Next.js VPS problems come from a short list of surprises. These are the ones that cost real time.
- ISR and the data cache are written to local disk on the instance. That works perfectly for one server, but if you ever scale to two, they will serve each other stale pages — at that point you need a shared cache handler.
- `next/image` optimizes at runtime and needs `sharp`, which on glibc-based Linux can use a lot of memory. If RSS creeps up over days, this is the usual culprit.
- Dynamically rendered pages send `private, no-cache, no-store` automatically. Do not add a caching layer in Nginx that overrides this, or you risk serving one user's page to another.
- Copy `public` and `.next/static` on every single build, not just the first. A stale copy means your CSS silently belongs to last week's deploy.
- Check your VPS renewal price before the term ends — the introductory rate is not the long-run rate.
## Where the cost lands
One KVM 1 server comfortably runs several Next.js apps side by side — add another PM2 process on port 3001, another Nginx server block, another certificate. That is the real economy of a VPS versus per-service platform pricing: the second app is free.
If you are provisioning one, coupon WEBHOST2026 applies the discount automatically through the links on this site, and longer terms carry the lower monthly rate.
---
# Host a MERN stack app cheaply in 2026
URL: https://www.discountoffer.store/blog/host-mern-stack-app-cheaply-2026
Published: 2026-09-10 · Category: Tutorials
> Three realistic ways to put MongoDB, Express, React and Node online for roughly the price of a coffee — with the security steps most tutorials skip.
## The three pieces, and where each one can live
A MERN app is really three deployables: a React bundle (static files), an Express/Node API (a long-lived process) and MongoDB (a database that needs persistent storage). Cost decisions get much easier once you stop thinking of it as one thing.
The static React build is nearly free to host anywhere. The API needs somewhere that will keep a process alive. The database is where the real money and the real risk live — and it is the piece most people get wrong.
## Three setups and what they actually cost
Prices below were checked in September 2026 and will drift. The trade-off column is the part that stays true.
| Setup | Roughly per month | The trade-off |
| --- | --- | --- |
| One VPS + MongoDB Atlas M0 | VPS only, DB free | Atlas M0 is genuinely free forever, but caps at 512 MB storage and ~100 ops/sec. Fine for a portfolio or an MVP; it will not carry a real product. |
| One VPS running everything, Mongo in Docker | VPS only | No database ceiling and no second bill, but backups, upgrades and security are entirely yours. This is the cheapest path with room to grow. |
| Managed PaaS + Atlas Flex | ~$7–37 for the app, up to $30 for the DB | Least operational work, highest and least predictable bill. Usage-based pricing can surprise you. |
> Atlas M0 allows one free cluster per project and around 100 operations per second. Hit that ceiling and requests queue rather than fail, which looks like mysterious latency rather than an obvious error — worth knowing before you debug the wrong layer.
## The cheapest sane setup: everything on one box
A single entry-tier VPS with 4 GB of RAM runs an Express API, a React build and MongoDB simultaneously without breaking a sweat, and the cost does not change when you add your next side project. Here is the whole thing.
Start by installing Node 24 LTS — the Active LTS line as of September 2026 — and Docker, which we will use for MongoDB so you are not chasing apt repository changes every time Mongo ships a major version.
On a fresh Ubuntu 24.04 or 26.04 server, as a sudo user:
```bash
# Node 24 LTS
curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -
sudo apt-get install -y nodejs nginx git
# Docker, for MongoDB
curl -fsSL https://get.docker.com | sudo sh
sudo usermod -aG docker $USER
# log out and back in so the group takes effect
```
## Run MongoDB without putting it on the public internet
This is the step to get right. Exposed, unauthenticated MongoDB instances have been the source of a long run of data breaches, and the default Docker command in most tutorials publishes the port to the world.
Two things make it safe: bind the published port to `127.0.0.1` so only processes on the same machine can reach it, and set root credentials on first run. Note that Docker writes its own iptables rules and can punch straight through UFW — a plain `-p 27017:27017` really is reachable from the internet even with a firewall you believe is closed.
The leading 127.0.0.1 in the port mapping is the entire security story:
```bash
docker volume create mongo-data
docker run -d \
--name mongo \
--restart unless-stopped \
-p 127.0.0.1:27017:27017 \
-v mongo-data:/data/db \
-e MONGO_INITDB_ROOT_USERNAME=appuser \
-e MONGO_INITDB_ROOT_PASSWORD='use-a-long-random-password' \
mongo:8
```
Verify it is NOT listening on a public interface:
```bash
sudo ss -tlnp | grep 27017
# Want: 127.0.0.1:27017
# Bad: 0.0.0.0:27017 <- reachable from the internet
```
> Your connection string then stays on the loopback interface: `mongodb://appuser:password@127.0.0.1:27017/myapp?authSource=admin`. Keep it in an env file that is not in Git.
## Run the Express API under PM2
PM2 restarts the API if it crashes and brings it back after a reboot. Bind it to loopback as well — Nginx is the only thing that should be able to reach it.
```bash
sudo npm install -g pm2
cd /var/www/api
npm ci --omit=dev
pm2 start server.js --name api
pm2 save
pm2 startup systemd
# run the sudo command PM2 prints, then 'pm2 save' again
```
In server.js, listen on loopback only:
```js
const PORT = process.env.PORT || 5000;
app.listen(PORT, "127.0.0.1", () => {
console.log("API listening on 127.0.0.1:" + PORT);
});
```
## Serve the React build and proxy the API from one domain
Serving the front end and API from the same origin removes your CORS problems entirely — the browser sees one domain. Nginx serves the static build from disk and forwards anything under `/api/` to Express.
The `try_files` line is what makes client-side routing work. Without it, a hard refresh on `/dashboard` returns a 404 because no such file exists on disk.
Build the React app and put it where Nginx can find it:
```bash
cd /var/www/client
npm ci
npm run build
# Vite outputs to dist/, Create React App to build/
```
/etc/nginx/sites-available/mern
```nginx
server {
listen 80;
server_name example.com;
root /var/www/client/dist;
index index.html;
location /api/ {
proxy_pass http://127.0.0.1:5000;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
# Client-side routing: unknown paths fall back to index.html
location / {
try_files $uri $uri/ /index.html;
}
}
```
Enable it, then add free HTTPS:
```bash
sudo ln -s /etc/nginx/sites-available/mern /etc/nginx/sites-enabled/
sudo rm -f /etc/nginx/sites-enabled/default
sudo nginx -t && sudo systemctl reload nginx
sudo apt-get install -y certbot python3-certbot-nginx
sudo certbot --nginx -d example.com
```
## Back up the database, because nobody else will
This is the cost of self-hosting Mongo, and it is small. A nightly `mongodump` into a dated folder, with anything older than two weeks deleted, covers the realistic failure modes: a bad migration, a dropped collection, a corrupted write.
Weekly server-level backups from your host protect you from losing the whole machine. They do not protect you from deleting a collection on Tuesday afternoon. You want both.
/home/deploy/backup-mongo.sh
```bash
#!/usr/bin/env bash
set -euo pipefail
STAMP=$(date +%F)
OUT=/home/deploy/backups/$STAMP
mkdir -p "$OUT"
docker exec mongo mongodump \
--username appuser \
--password "$MONGO_PASSWORD" \
--authenticationDatabase admin \
--archive > "$OUT/myapp.archive"
# Keep two weeks
find /home/deploy/backups -maxdepth 1 -type d -mtime +14 -exec rm -rf {} +
```
Schedule it with crontab -e:
```bash
0 3 * * * MONGO_PASSWORD='...' /home/deploy/backup-mongo.sh >> /home/deploy/backup.log 2>&1
```
> A backup you have never restored is a hypothesis, not a backup. Restore one into a throwaway container once, confirm the data is there, and you will sleep better.
## When to stop self-hosting the database
Running Mongo yourself is the right call while your data fits comfortably on one disk and downtime during a restore is survivable. Move to managed hosting when any of the following become true — and notice that all three are about consequences, not scale.
- A few hours of downtime during a restore would genuinely hurt the business.
- You need point-in-time recovery rather than 'yesterday at 3am'.
- You want replica-set failover, and standing one up yourself is no longer a fun afternoon.
## The short version
For a side project or an MVP, one VPS running React, Express and Mongo together is the cheapest arrangement that does not box you in, and the price stays flat as you add projects. Start on Atlas M0 if you would rather not own a database yet; move Mongo onto the box when 512 MB stops being enough.
Coupon WEBHOST2026 applies automatically through the links here if you are picking up a server for this.
---
# Hostinger VPS vs a $5 DigitalOcean droplet for a side project
URL: https://www.discountoffer.store/blog/hostinger-vps-vs-digitalocean-droplet
Published: 2026-09-08 · Category: Comparisons
> The $5 droplet is $6 now, and it ships 1 GB of RAM. Here is the honest spec-and-cost comparison, including the renewal maths that most affiliate posts leave out.
## First, the $5 droplet is $6
DigitalOcean's famous $5 droplet has not existed at that price for a while. The Basic line now starts at $4/month for 512 MB of RAM, and the entry point most people actually want is $6/month for 1 GB. That $4 tier is a trap for anything Node-shaped: 512 MB will not build a Next.js app, and often will not run one.
So the real comparison for a side project is Hostinger's KVM 1 against DigitalOcean's $6 Basic droplet. They cost roughly the same per month. They are not remotely the same machine.
## Spec for spec
Figures checked September 2026. Hostinger's promotional price depends on term length; the renewal rate is what you pay from year two onward, and it is the number that decides this comparison.
| | Hostinger KVM 1 | DigitalOcean Basic $6 |
| --- | --- | --- |
| Promo price | ~$6.49/mo on a long prepaid term | $6.00/mo, no promo |
| Renewal price | ~$11.99/mo | $6.00/mo — the price never changes |
| vCPU | 1 (AMD EPYC) | 1 shared |
| RAM | 4 GB | 1 GB |
| Storage | 50 GB NVMe | 25 GB SSD |
| Outbound transfer | 4 TB | 1 TB |
| Billing model | Prepaid 12, 24 or 48 months | Per-second, capped at the monthly rate |
| Backups | Weekly, included | +20% weekly or +30% daily |
| Snapshots | Included | $0.06/GB per month |
| Walking away | 30-day money-back, then you are committed | Destroy the droplet, billing stops |
## Four gigabytes of RAM is the headline
On paper this looks like a modest difference. In practice it decides what you can actually run. A 1 GB droplet will not complete a `next build` without a swap file, and even with swap the build crawls. Docker Compose with an app plus Postgres plus Redis is tight on 1 GB and comfortable on 4 GB.
This is the single strongest argument for the Hostinger box: at the same monthly price you get four times the memory and twice the disk. If your side project is a Next.js app, a MERN stack, or anything that builds on the server, that is not a marginal win.
DigitalOcean's answer is to move up to the $12 tier for 2 GB, or $24 for 4 GB with 2 vCPUs. At $24/month versus roughly $6.49, the value comparison stops being close.
## Now the maths that affiliate posts skip
Hostinger's pricing is promotional and prepaid. You are buying 12, 24 or 48 months up front at a discounted rate, and it renews substantially higher. DigitalOcean charges the same $6 forever. Over a long enough horizon those two models produce very different answers, so here is the actual arithmetic.
Two years, entry tier: roughly $156 prepaid for the Hostinger box against $144 for the droplet. Near enough identical — except one has 4 GB of RAM and the other has 1 GB.
Four years on a 48-month term: Hostinger lands near $240 against $288 for the droplet. Cheaper and substantially more machine.
But renew that Hostinger server at the standard rate instead and you are paying about $12/month against DigitalOcean's $6. The discount is real, and it is finite.
> The rule that falls out of this: Hostinger wins decisively if you commit up front and stay for the full term. DigitalOcean wins if you might cancel in three months, or if you value never thinking about renewal pricing again.
## What DigitalOcean gives you that Hostinger does not
Specs are not the whole product, and this is where the droplet earns its keep.
- Per-second billing. Spin a box up for an afternoon's experiment and pay cents. Hostinger sells you a year minimum.
- A real ecosystem around the droplet: managed Postgres and MySQL, Spaces object storage, load balancers, managed Kubernetes. When your side project grows a second component, it is a click rather than a migration.
- No renewal cliff, ever. The price you sign up at is the price in year five.
- Deep documentation and a very large community — for a huge range of problems, someone has already written the DigitalOcean tutorial.
- Easy exit. Destroy the droplet and billing stops that second.
## What Hostinger gives you that the droplet does not
And this is where the KVM plans earn theirs.
- Four times the RAM at the same entry price, on AMD EPYC with NVMe storage.
- Weekly backups included rather than a 20–30% surcharge, plus manual snapshots at no extra cost.
- Over 100 one-click application templates — Docker, n8n, GitLab, WordPress — and a choice of control panels if you want cPanel, Plesk or CloudPanel rather than a bare shell.
- A browser-based terminal, which is genuinely useful the day you break your SSH config.
- 4 TB of outbound transfer against 1 TB.
## So which one
The decision is really about your confidence in the project, not about the hardware.
- Prototyping, or unsure it survives the quarter → DigitalOcean. Hourly billing and a clean exit are worth more than extra RAM you may never use.
- A project you intend to run for years, and you want the most machine per dollar → Hostinger, on the longest term you are comfortable prepaying.
- You need managed databases, object storage or a load balancer → DigitalOcean, without much debate. Hostinger expects you to run those yourself on the box.
- You want to host several side projects on one server → Hostinger. 4 GB absorbs four or five small apps; 1 GB does not.
- You are memory-constrained by a build step → Hostinger, or budget $24/month at DigitalOcean for comparable RAM.
> Full disclosure: this site earns a referral commission if you buy Hostinger through our links. That is exactly why the renewal pricing is spelled out above — a comparison that hides the number you will pay in year two is not worth reading.
## One more option worth a look
If neither appeals, Hetzner's shared-vCPU line is consistently the cheapest specs-per-euro in the market, with no promotional pricing games. The catch is fewer datacenter regions and a signup process that sometimes asks for ID verification. Worth knowing it exists before you decide the field is only two players.
If you do go with Hostinger, coupon WEBHOST2026 is applied automatically through the links on this site, and the 48-month term carries the lowest monthly rate.
---
# Cheapest way to host a Node.js API
URL: https://www.discountoffer.store/blog/cheapest-way-to-host-nodejs-api
Published: 2026-09-05 · Category: Comparisons
> Free tiers, $7 PaaS plans and $6 VPS boxes compared on what they actually cost once your API needs to stay awake — plus a three-line Caddy setup with automatic HTTPS.
## The question behind the question
'Cheapest' depends entirely on one thing: whether your API is allowed to fall asleep. Free tiers are free because they suspend your process when traffic stops, and waking it takes several seconds. For a hobby dashboard you check twice a week, that is fine. For anything a user waits on, a multi-second cold start is worse than no API.
Once you rule out sleeping, the field narrows quickly and the prices converge around $5–7/month. What differs is what you get for it.
## What the options cost in September 2026
The free-tier landscape has tightened considerably. Fly.io no longer offers a free tier to new accounts and requires a card. Railway has no permanent free tier. Render still offers a genuinely free web service, with the cold-start caveat.
| Option | Realistic monthly cost | What you actually get |
| --- | --- | --- |
| Render free | $0 | 512 MB, no card required, sleeps after inactivity. Cold starts measured in seconds. |
| Render Starter | ~$7 per service | Always-on 512 MB, managed deploys from Git, zero server admin. |
| Railway Hobby | ~$5–7 for a small always-on API | Usage-based, widely considered the best developer experience of the three. |
| Fly.io | ~$5–12 | Card required, no free tier for new users. Worth it specifically for multi-region or edge deployment. |
| Entry VPS (e.g. KVM 1) | ~$6.49 on a long term | 1 vCPU, 4 GB RAM, 50 GB NVMe, root access — and it hosts every other project you own at no extra cost. |
## The pricing model matters more than the price
Here is the part that decides it for most people. Managed platforms bill per service. Your API is one service; add a worker and that is two; add a staging environment and that is three. At roughly $7 each, three services is $21/month and climbing.
A VPS bills per machine. The second API on that box costs nothing. So does the third, the cron worker, the Postgres instance and the staging copy. A 4 GB server absorbs a surprising number of small Node processes before it complains.
So the honest answer is: for exactly one API, a PaaS is cheaper once you price your own time. For three or more things, a VPS wins on cost and keeps winning.
> The cost a VPS does not put on the invoice is your attention: OS updates, TLS renewal, firewall rules, backups, and being the person who gets paged. If that is worth more than $15/month to you, pay the PaaS and stop reading.
## The fastest VPS setup: Caddy instead of Nginx
If you only need a reverse proxy with HTTPS, Caddy does in three lines what Nginx plus Certbot does in about forty. It obtains and renews Let's Encrypt certificates automatically, with no cron job and no separate tool. For a small API this is the correct default.
Start with Node 24 LTS — the Active LTS line as of September 2026 — and PM2 to keep the process alive.
On a fresh Ubuntu server:
```bash
curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -
sudo apt-get install -y nodejs
sudo npm install -g pm2
cd /var/www/api
npm ci --omit=dev
pm2 start server.js --name api
pm2 save
pm2 startup systemd
# run the sudo command PM2 prints, then 'pm2 save' again
```
Bind to loopback so only the proxy can reach your API:
```js
const PORT = process.env.PORT || 5000;
app.listen(PORT, "127.0.0.1", () => {
console.log("API on 127.0.0.1:" + PORT);
});
```
Install Caddy:
```bash
sudo apt-get install -y debian-keyring debian-archive-keyring apt-transport-https curl
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' \
| sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' \
| sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt-get update && sudo apt-get install -y caddy
```
/etc/caddy/Caddyfile — this is the whole config
```caddyfile
api.example.com {
reverse_proxy 127.0.0.1:5000
}
```
Reload, and HTTPS is live:
```bash
sudo systemctl reload caddy
curl -I https://api.example.com
```
> Point your domain's A record at the server before reloading Caddy. It requests the certificate immediately on startup, and the request fails if DNS has not propagated yet.
## Adding a second API costs you one block
This is the whole argument for a VPS, expressed in configuration. Another PM2 process on another port, another three lines in the Caddyfile, another certificate issued automatically. Your bill does not move.
```bash
cd /var/www/api-two
PORT=5001 pm2 start server.js --name api-two
pm2 save
```
```caddyfile
api.example.com {
reverse_proxy 127.0.0.1:5000
}
api2.example.com {
reverse_proxy 127.0.0.1:5001
}
```
## Things that quietly cost money later
The sticker price is rarely the final price. These are the line items that show up in month three.
- Bandwidth. Most VPS plans include several terabytes; managed platforms are often stingier and bill overage. If your API serves files or images, check this number first.
- Backups. Included weekly on many VPS plans; a 20–30% surcharge at some cloud providers.
- The database. A free Atlas or Postgres tier is fine until it is not, and managed database pricing tends to exceed the compute it serves.
- Cold starts on free tiers. They cost user patience rather than dollars, which is easy to under-price until someone complains.
- Renewal rates on promotional VPS pricing. Introductory rates roughly double on renewal — budget for the real number, not the launch offer.
## Pick in one line
Reduced to a single sentence each:
- One API, occasional traffic, zero ops appetite → Render's free tier, and accept the cold starts.
- One API that must stay awake and you would rather not own a server → Render Starter or Railway, around $7.
- Two or more services, or a database you want on the same box → an entry VPS, and the marginal cost of each addition is zero.
- Multi-region or edge latency requirements → Fly.io, which is the one case where it clearly beats the others.
## If you go the VPS route
An entry KVM plan with 4 GB of RAM handles a Node API, a database and several other small projects at once, which is what makes the per-machine pricing model pay off. Coupon WEBHOST2026 applies automatically through the links on this site, and longer terms carry the lower monthly rate.
---
# Hostinger for developers — is the VPS actually good?
URL: https://www.discountoffer.store/blog/hostinger-vps-for-developers-honest-review
Published: 2026-09-03 · Category: Reviews
> An honest look at the KVM line from a developer's perspective: what the hardware really gives you, where the renewal pricing bites, and the four cases where you should buy something else.
## The short answer
Yes, with one significant caveat. The hardware is genuinely good for the money — AMD EPYC, NVMe, and an entry tier with 4 GB of RAM where most competitors give you 1 GB at the same price. For a developer who wants root on a capable box and is happy to configure it, the KVM line is among the best value available.
The caveat is the pricing model. These are promotional, prepaid rates that roughly double on renewal. Buy it understanding that, and it is a strong deal. Buy it expecting $6/month forever and you will be annoyed in about a year.
Disclosure before anything else: this site earns a referral commission on Hostinger purchases. That is precisely why the renewal numbers and the weak points below are stated plainly — a review that only lists strengths is an advertisement.
## The line-up
Four KVM tiers, all on AMD EPYC with NVMe storage and a dedicated IP. Specs as of September 2026.
| Plan | vCPU | RAM | NVMe | Transfer |
| --- | --- | --- | --- | --- |
| KVM 1 | 1 | 4 GB | 50 GB | 4 TB |
| KVM 2 | 2 | 8 GB | 100 GB | 8 TB |
| KVM 4 | 4 | 16 GB | 200 GB | 16 TB |
| KVM 8 | 8 | 32 GB | 400 GB | 32 TB |
> Note the RAM-to-vCPU ratio: 4 GB per core across the line. That is memory-generous and CPU-lean, which tells you exactly what these boxes are good at and what they are not.
## What is genuinely good
Taking the developer-relevant features one at a time, rather than reprinting the marketing page.
- 4 GB of RAM at the entry tier. This is the standout. It means `next build` completes, Docker Compose with three services runs, and you are not immediately shopping for a bigger box.
- Weekly backups included, plus manual snapshots at no extra charge. Several cloud providers bill 20–30% of the instance price for equivalent backups.
- Over 100 one-click application templates — Docker, n8n, GitLab, WordPress, various AI frameworks — and one-click OS installs across Ubuntu, Debian, AlmaLinux and CentOS.
- A browser-based web terminal. Niche until the day you lock yourself out over SSH, at which point it is the difference between a five-minute fix and a support ticket.
- A public API with an MCP server, so you can drive server management from AI tooling. Unusual at this price point.
- Optional control panels (cPanel, Plesk, DirectAdmin, CloudPanel, HestiaCP) if you would rather not live in a shell.
- 4 TB of transfer at the entry tier, which is several times what comparable entry instances include.
## What is not good
The honest list. None of these are dealbreakers on their own; together they define who should look elsewhere.
- Renewal pricing roughly doubles. Third-party reviews consistently report VPS renewals at around 100% above the introductory rate, and reviewers note it is not made especially prominent at checkout. Read the renewal figure before you commit.
- Prepaid terms only. There is no hourly billing and no spin-up-for-an-afternoon. You buy 12, 24 or 48 months, with a 30-day money-back window and no exit after that.
- One vCPU at the entry tier. The RAM is generous; the CPU is not. Anything genuinely compute-bound — large builds, video transcoding, heavy image processing — will feel it regardless of the 4 GB.
- Support has shifted decisively toward AI-first. Reviewers repeatedly flag this. If you want a human on a complex routing problem quickly, expect to work for it.
- Measured uptime sits around 99.95% in independent testing — roughly an hour of downtime per quarter. Perfectly respectable, not best-in-class.
- No managed services. There is no managed Postgres, no object storage, no load balancer. Everything beyond the VM is yours to run. For some developers that is the point; for others it is a hard stop.
## How it behaves in practice
The 4 GB entry tier changes what an entry server can do, and that is not a small thing. A Next.js production build that would swap-thrash and time out on a 1 GB instance completes without special handling. Docker Compose running an app, Postgres and Redis together is comfortable rather than precarious. Several small Node APIs coexist under PM2 with room left over.
The single vCPU is the real ceiling. Builds are not fast — memory-generous is not the same as quick, and a large compile will take its time. If your workflow is build-on-the-server-on-every-push, either accept the wait, move to KVM 2, or build in CI and ship the artifact.
NVMe storage makes the database work you would actually do on a box like this feel fine. Disk is not the bottleneck here; the CPU is.
## Who should buy it
The fit is quite specific, and clear once you see it.
- Developers hosting several side projects on one machine. This is the sweet spot — 4 GB absorbs four or five small apps, and the second project costs nothing.
- Anyone self-hosting memory-hungry tooling: n8n, GitLab, Supabase, a handful of Docker services.
- People running a project they are confident about for years, who can prepay a long term and take the lower rate.
- Developers who want root and are comfortable owning updates, TLS and backups.
## Who should buy something else
Equally clear, and worth being direct about.
- Anyone who might cancel in three months. Prepaid terms are the wrong shape for uncertainty — take hourly billing elsewhere.
- Teams that need managed databases, object storage or load balancers. That ecosystem does not exist here.
- CPU-bound workloads. One vCPU at the entry tier is the constraint, and the RAM does not compensate.
- Anyone who wants fast human support on complex infrastructure problems.
- Projects with a hard uptime SLA. 99.95% is good; it is not a guarantee you can resell.
## Verdict
As hardware per dollar, the KVM line is excellent and the 4 GB entry tier is a real differentiator rather than a spec-sheet trick. As a commercial arrangement, it asks you to prepay for years and accept a substantial renewal increase, and it gives you a VM rather than a platform.
If you are a developer with a few projects, a preference for root access and a multi-year horizon, it is one of the best-value servers you can buy. If you want flexibility, managed services, or the ability to walk away next month, the extra few dollars elsewhere buys something you will actually use.
If it fits, coupon WEBHOST2026 is applied automatically through the links on this site, and the 48-month term carries the lowest monthly rate — just note down the renewal figure before your term ends.
---
# How to use the Hostinger coupon WEBHOST2026 (step by step)
URL: https://www.discountoffer.store/blog/how-to-use-hostinger-coupon-webhost2026
Published: 2026-09-01 · Category: Deals
> Apply coupon WEBHOST2026 in three clicks and stack it with a long-term plan to get the lowest possible price on Hostinger hosting.
## What is coupon WEBHOST2026?
WEBHOST2026 is an exclusive Hostinger discount code shared through DiscountOffer.Store. It applies an extra discount on top of Hostinger's promotional pricing when you choose a longer billing term.
The easiest way to use it is through a ready-made cart link that attaches the coupon automatically — no typing required.
## Apply the coupon in 3 steps
Follow these steps to make sure the discount sticks:
- Open a discount link from this site (the coupon is pre-attached).
- Pick your plan and a 12, 24 or 48-month term — longer terms cost less per month.
- Confirm the coupon shows in the order summary before you pay.
- [What the extra 20% off covers, with real prices](https://www.discountoffer.store/blog/hostinger-coupon-code-20-off)
- [Coupon not applying? 8 fixes](https://www.discountoffer.store/blog/hostinger-coupon-not-working-fixes)
## Pro tip: choose the 48-month term
Hostinger's per-month price drops as the term gets longer. The 48-month plan gives the biggest saving, followed by 24 and then 12 months. If you're committed to your project, the longest term is almost always the best value.
---
# Hostinger plans explained: which one should you choose?
URL: https://www.discountoffer.store/blog/hostinger-plans-explained-which-to-choose
Published: 2026-08-20 · Category: Guides
> Web, cloud, VPS or WordPress hosting? A plain-English guide to picking the right Hostinger plan for your project and budget.
## Start with what you're building
The right plan depends on your project. A blog or small business site needs far less than a busy online store or a custom web app.
- Blog / portfolio / small site → Web Hosting (Single or Premium).
- Multiple sites or a small store → Web Hosting Business.
- Growing store or agency → Cloud Hosting.
- Developers who need control → VPS Hosting.
## Web hosting: the easy default
Shared web hosting is the simplest and cheapest way to get online. Premium is the sweet spot for most people: multiple websites, a free domain and email, and plenty of storage.
## Cloud vs VPS
Cloud hosting gives you dedicated resources without any server management — great for stores that outgrow shared hosting. VPS hosting hands you full root access and is aimed at developers who want to configure everything themselves.
---
# 12 vs 24 vs 48-month hosting: which term saves the most?
URL: https://www.discountoffer.store/blog/12-vs-24-vs-48-month-hosting-which-saves-most
Published: 2026-08-05 · Category: Deals
> The billing term you choose changes your monthly price a lot. Here's how 12, 24 and 48-month Hostinger plans compare.
## Longer term, lower monthly price
Hostinger rewards commitment. The same plan costs less per month when you pay for a longer term up front, because the introductory discount is spread over more months.
## Which should you pick?
If you're testing an idea, 12 months keeps your upfront cost low. If you know the project is here to stay, 48 months gives the lowest monthly price and the best overall value. 24 months is a solid middle ground.
- 12 months — lowest upfront cost, good for testing.
- 24 months — balanced price and commitment.
- 48 months — lowest monthly price, best long-term value.