Free / self-hosted stack on your VPS — organized notes الحزمة المجانية والمستضافة ذاتيًا على VPS — ملاحظات منظّمة

The architecture and principles stay almost identical (Next.js + Postgres + Redis + caching + ISR-style pages + Cloudflare + atomic notes + pre-translated content), but we replace the managed/paid services with self-hosted or free-tier alternatives so your ongoing cost stays near zero (only the VPS itself).

Free / Self-Hosted Stack (Recommended for Your VPS)

How to Run It on Your VPS (Easiest Practical Way)

1. Use Docker Compose with services: next-app, postgres, redis, meilisearch, libretranslate (optional), nginx.
2. Put Cloudflare free in front (DNS + proxy + caching rules).
3. Use Let's Encrypt (free SSL) via Certbot or Cloudflare.
4. Deploy with a simple script or tools like Coolify / CapRover if you want an easier “self-hosted Vercel-like” experience.

Important Trade-offs (Be Honest)

• Translation quality: Lower if you stay 100% free with LibreTranslate. Google free tier (500k characters/month) + Redis caching is usually the better practical choice.
• Speech quality: Noticeably weaker with only browser Web Speech API. Real-time conversation mode will feel less smooth.
• Operations: You are responsible for updates, backups, security patches, and monitoring. A small VPS can handle moderate traffic, but high concurrent users will require a stronger VPS (recommend at least 4–8 GB RAM).
• Scaling: Vertical (bigger VPS) or later add more servers. Not as automatic as Vercel.
• Data & content strategy: Stays exactly the same (Wikivoyage + official sources + human review + confidence scores).

Recommended Free Path

Start with this hybrid free approach (best balance):

• Self-host everything possible on your VPS (Next.js, Postgres, Redis, Meilisearch).
• Use Cloudflare free.
• Use Google Cloud Translation free tier + aggressive Redis caching for text.
• Use Browser Web Speech API for speech MVP.
• Later migrate pure self-hosted translation/speech if free quotas become a problem.

This keeps the same clean architecture we recommended before, just without monthly cloud bills.

When you move from managed platforms (Vercel, Supabase, paid APIs) to your own VPS, you trade convenience for cost control. You now do the DevOps, but your monthly bill drops to essentially zero (just the VPS you already have).

1. The Free/Self-Hosted Stack

2. What Stays the Same

• Next.js still works, but you will likely use output: 'export' to generate static HTML/JS and let Nginx serve it. This is much faster than running a Node.js server for content pages.
• PostgreSQL + Redis + Meilisearch architecture remains identical — you just run them in Docker instead of paying for managed instances.
• Content strategy (atomic notes, editorial workflow, i18n routing) is unchanged.
• Cloudflare sits in front of your VPS to cache pages globally and absorb traffic spikes.

3. What Changes Radically: Translation

This is the hardest part to do for free. Neural translation and speech recognition are compute-heavy.

Text Translation (Free Options)

My recommendation:

• Run LibreTranslate on your VPS for instant chat/phrase translation (unlimited, no rate limits).
• Use Azure Translator free tier for pre-translating your curated country notes (2M chars/month is enough for steady content updates).
• For Arabic↔Japanese/Korean/Urdu, LibreTranslate is usable but not perfect. Have a disclaimer: "Community-powered translation — verify critical info."

Speech Translation (Free Options)

My recommendation for a free app:

• Phase 1: Use the Browser Web Speech API entirely. It runs on the user's phone, costs you nothing, and requires zero backend infrastructure. Add a big microphone button.
• Phase 2: If quality complaints arise, proxy audio to your VPS running faster-whisper (small model) as a fallback. Warn users it takes 2-3 seconds.

4. Docker Compose for Your VPS

This single file runs your entire backend on one VPS:

# docker-compose.yml
version: '3.8'

services:
  postgres:
    image: postgres:16-alpine
    restart: always
    environment:
      POSTGRES_USER: tourism
      POSTGRES_PASSWORD: your_secure_password
      POSTGRES_DB: tourism_db
    volumes:
      - pgdata:/var/lib/postgresql/data
    ports:
      - "127.0.0.1:5432:5432"  # Only local access

  redis:
    image: redis:7-alpine
    restart: always
    volumes:
      - redisdata:/data
    ports:
      - "127.0.0.1:6379:6379"

  meilisearch:
    image: getmeili/meilisearch:v1.9
    restart: always
    environment:
      MEILI_MASTER_KEY: your_meili_key
    volumes:
      - meilisearch:/meili_data
    ports:
      - "127.0.0.1:7700:7700"

  libretranslate:
    image: libretranslate/libretranslate:latest
    restart: always
    environment:
      LT_UPDATE_MODELS: "true"
    volumes:
      - libretranslate:/home/libretranslate/.local
    ports:
      - "127.0.0.1:5000:5000"

  api:
    build: ./api  # Your Fastify/FastAPI backend
    restart: always
    environment:
      DATABASE_URL: postgres://tourism:your_secure_password@postgres:5432/tourism_db
      REDIS_URL: redis://redis:6379
      MEILI_URL: http://meilisearch:7700
      TRANSLATE_URL: http://libretranslate:5000
    depends_on:
      - postgres
      - redis
      - meilisearch
      - libretranslate
    ports:
      - "127.0.0.1:3001:3001"

volumes:
  pgdata:
  redisdata:
  meilisearch:
  libretranslate:

Nginx config (/etc/nginx/sites-available/tourism)

server {
    listen 80;
    server_name yourdomain.com;

    # Let's Encrypt SSL (certbot handles this)

    # Cache static assets for 1 year
    location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2)$ {
        root /var/www/tourism/dist;
        expires 1y;
        add_header Cache-Control "public, immutable";
    }

    # Serve frontend static export
    location / {
        root /var/www/tourism/dist;
        try_files $uri $uri/ /index.html;

        # Cache HTML at Cloudflare edge, not here
        add_header Cache-Control "public, max-age=0, must-revalidate";
    }

    # Proxy API requests
    location /api/ {
        proxy_pass http://127.0.0.1:3001/;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

5. Handling High Traffic on a Single VPS

A $5–$20/month VPS (2–4 vCPU, 4–8GB RAM) can handle surprising traffic if you are disciplined:

Realistic capacity: With Cloudflare caching static pages, a single 4GB VPS can serve 50,000–100,000 page views/day easily. The bottleneck becomes translation API calls (if not cached in Redis).

6. The Honest Trade-offs of "Free"

7. Recommended Build Order (Free VPS Path)

1. Week 1: Docker Compose (Postgres + Redis + Meilisearch) + Nginx + static React/Vite frontend
2. Week 2: Content schema + seed 10 countries from Wikivoyage (with attribution)
3. Week 3: Meilisearch indexing + language routing + RTL support
4. Week 4: LibreTranslate container + text translation widget
5. Week 5: Browser Web Speech API integration (microphone button)
6. Week 6: Cloudflare caching + PgBouncer + rate limiting
7. Week 7: Load testing + monitoring (Uptime Kuma)

Bottom Line

No, it is not the same stack — but it is the same architecture. You swap managed services for self-hosted Docker containers and accept lower translation quality (or strict free-tier API limits) in exchange for zero recurring platform costs.

If your VPS has at least 4GB RAM, this is absolutely viable for a free tourism app. If it is a 1GB VPS, drop Meilisearch and use PostgreSQL full-text search instead to save memory.

A large part of the earlier recommendation assumed managed cloud (Vercel, Supabase, Upstash, paid translation APIs). Those are not “free” once you leave the trial. On a VPS you already own, most of that is replaced by self-hosted free pieces. Translation and speech are the real fork.

What changes and what does not

This part is a clean swap — free, and honestly not much harder. Translation and speech are where you have a real decision.

Option A — fully self-hosted, no external dependency

• Text: LibreTranslate (Docker, Argos Translate) — covers Arabic, Indonesian, Malay, Japanese, Korean, Chinese, and Urdu on its supported list, so your full list is there
• STT: faster-whisper (small/medium, CPU, int8 quantization) — on a decent VPS near real-time
• TTS: Piper — CPU only, a few hundred MB RAM, 30+ languages
• Cost: literally $0 forever, no API keys, no data leaving your server
• Trade-off: translation generally lags DeepL/Google on precise text; speech feels slower than a cloud API — a few seconds per sentence on a modest VPS CPU, not the sub-second feel of streaming Azure

Option B — app self-hosted, keep Google/Azure free tiers

• Google Cloud Translation: free tier 500,000 characters/month, permanent — does not expire
• Azure Translator: free tier 2 million characters/month, the most generous among major vendors, no expiry
• Azure Speech: free tier includes 5 audio hours/month STT, 500,000 characters/month neural TTS, and 5 audio hours/month speech translation
• Cost: $0 until you exceed the cap, then pay-as-you-go
• Trade-off: external dependency and a hard ceiling — fine for launch and testing, but 5 audio hours/month is roughly “a few hundred short conversations,” not real monthly product volume once you have users

Recommendation: Option B for translation and speech, Option A for everything else. Self-hosting the app/DB/cache/search costs you nothing extra either way, so do that regardless. Replacing Google/Azure free tiers with LibreTranslate+Whisper+Piper only saves money you were not spending yet, while it costs real quality — and running Whisper well eats CPU the single VPS also needs to serve pages. Start on API free tiers; migrate to a self-hosted ML stack only when the bill becomes real because you have enough traffic.

VPS sizing

For the self-hosted core (Next.js + Postgres + Redis + Meilisearch), 2 vCPU / 4 GB RAM is actually enough at modest traffic, because Cloudflare + Redis + ISR-style static pages absorb most reads before they hit the box. If you pick Option A and add faster-whisper / LibreTranslate / Piper on the same box, raise to 4 vCPU / 8 GB RAM — those models need room, and a ~€15/month box (e.g. Hetzner CPX41 or similar) runs a small/medium Whisper model comfortably near real-time on CPU.

One thing worth resetting

The earlier “high traffic” picture assumed auto-scaling across many servers — that is not available on one VPS. In practice this matters less than it sounds: content browsing is heavily cached (Cloudflare + Redis + ISR static pages), so one modest VPS handles a surprising amount of that traffic. The part that will squeeze the single box first is concurrent live speech sessions, because that is CPU per active user — that is the one thing worth rate-limiting early no matter which translation option you pick.

Shared core: Next.js 14 + Tailwind PWA; Postgres on VPS + Prisma; MinIO; Caddy; Leaflet+OSM; LibreTranslate; Web Speech + Whisper.cpp fallback. Three apps share ~90% stack, monorepo, deploy three times.

Tourism translator (this file’s easiest path)

• Browser STT/TTS → Caddy → Next PWA :3000 + LibreTranslate :5000.
• Phase 1 langs: AR (MSA+Egyptian), EN, ID, MS, JA, KO, ZH, UR.
• 7-day MVP: text, hold-to-speak, speech→speech, auto detect, split conversation, 200 phrases, Tesseract, localStorage, PWA.
• Comparison: Web Speech+LT = $0 / 7/10 / self-host — “best lazy choice.” Google/Azure/OpenAI are paid quality bumps.
• 90-day: weeks 1–2 monorepo+Caddy; 3–4 translator live; 5–6 Mom; 7–8 Egypt; 9–10 payments; 11–12 TikTok/SEO.
• Fixed cost ~$1/mo on existing VPS. Ponytail: no RN/Flutter, no k8s, no custom MT until >5% complaints, no Redis until 100K MAU.

One shared compose: Caddy 30 MB, PostGIS 1–1.5 GB, LibreTranslate 1–2 GB, Plausible 150 MB, MinIO 200 MB, Uptime Kuma 30 MB. Total ~3–4 GB — fits 8 GB with headroom. LT has no public port.

• Caddyfile hosts: translate / egypt / ar.addict.mom / en.addict.mom + gated plausible/minio/kuma.
• Backup: Litestream→MinIO for SQLite (RPO ~1 s). Postgres: nightly pg_dump + WAL via pgBackRest, Restic to Storage Box, keep 7/4/6. Test restore monthly.
• Every app: /healthz liveness + /readyz (SELECT 1). Kuma every 30s; alert after 2 failures.
• Topology example: Hetzner CX32 8 GB for shared+Mom; Contabo for Egypt/LT split; ai-developer = Restic/Ollama. Split LT when CPU >70% for 10 min or QPS >5.
• Logs day 1: Caddy + logrotate + grep. Loki only if SSH debug >1 h/week. No ELK.

Bugs that apply to any VPS compose (do not repeat)

• Web Speech onend stale closure → use isListeningRef.
• UI language list must match LT_LOAD_ONLY.
• Do not publish LibreTranslate :5000 — expose + LT_DISABLE_WEB_UI=true (saves ~20 MB, stops API bypass).
• Drizzle .where() needs eq(); FAQ confidence must not be score*2.

Resource table (honest): Caddy 30 · Translator 150 · LT 2.50 GB · Egypt 300 · PostGIS 200 · Arabic Mom 150 · English Mom 200 ≈ 3.53 GB + Kuma 30. Headroom ~11 GB on a 15 GB box. Logging: json-file 10m×3, not Grafana (0 extra RAM).

3-tier MT (Gemini, adopted by BUILD-01): (1) Web Speech + optional Bergamot/Transformers.js WASM — 0 server load; (2) LibreTranslate on VPS; (3) HuggingFace free for long-tail langs. WASM is a speed fallback (BLEU 4–6/10), not the quality primary.

P0: split-screen voice, text always visible, 8 langs, Tesseract, cultural tooltips, offline packs, 60/min, healthz/readyz. P1: WebRTC group room (expert: Google’s 1:1 is clunky). P2: Coqui XTTS needs ~8 GB — not on the shared fleet.

Limits (BUILD-01 table): Firefox no STT; iOS 60 s; LT Egyptian dialect 3–4/10 so phrasebook on critical paths; Arabic OCR 70–80%; concurrency 2–5K not 50K. k6 ramps to 2000 VUs, p95 <1 s, error <5%.

Grok 04 browser matrix: Chrome Android good; Safari iOS limited; type box always. High-traffic: LRU cache, 50–100 free/day, LT_LOAD_ONLY, isolate LT, never accept wav on free tier, 503+phrasebook if overloaded.